simplecov 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f159cd5427690b20f11c1e4a3f1a90c23c16f5f65e2043205bf132a5abc0218
-  data.tar.gz: d5a28a2c529ff2b59652bd0c1ba1f9d649c7c24fd02521905c6d2cbe6b1eeae3
+  metadata.gz: ddfad3987b6f04c755c08c2b251d111ca75eff0e14aef5156e9d30f049087e96
+  data.tar.gz: 97efb84c53398cc92a3e2106d2428351f3f1edc37cc4a7c34abeb2859503a0fd
 SHA512:
-  metadata.gz: 792c138d327b5d305ebe273dfd5a97d70eb8104102557d5ae6452a26d5cc64e1db7720c3de5e2c556a78b22561c53778579909ddef7f4615e1c447f041fa921c
-  data.tar.gz: 9f6479ceabbd5f6fc24585a2134a0f4e1270dbd988922d4d387e5695055b811655999b3d95c2a9b31c960cf0c22aa884d5bf94eae93ca6fb97868bbec0de3aab
+  metadata.gz: ac211a4d93fe0db4e87f4ddddff178566e84ef2d04234ffba49382da236668f718ef43d2b68b01977e1aa17dec86823dbc70cb8adf7eb116a9f24f06a99d78c2
+  data.tar.gz: 5259cbb289b03d111995433363370d3e91729da55c9aef5834a0626cfd11fc93fa6614fab3f764e8faaa667439a6716cb1e842f343c58875fd83c023977f6c99

data/README.md

@@ -1042,6 +1042,20 @@ SimpleCov.formatter = SimpleCov::Formatter::HTMLFormatter
 `SimpleCov.result.format!` then invokes `SimpleCov::Formatter::YourFormatter.new.format(result)`, where `result` is a
 `SimpleCov::Result`. Do whatever you wish with it.
 
+### Passing options to formatters
+
+Anywhere a formatter class is accepted, a ready-built instance works too — that's how you reach constructor options.
+The built-in HTML and JSON formatters take `silent: true` to suppress the "Coverage report generated" status line on
+stderr, and `output_dir:` to write the report somewhere other than `SimpleCov.coverage_path`:
+
+```ruby
+SimpleCov.start do
+  formatter SimpleCov::Formatter::HTMLFormatter.new(silent: true)
+end
+```
+
+Instances mix freely with classes in `formatters` lists as well.
+
 ### Using multiple formatters
 
 As of SimpleCov 0.9 you can specify multiple result formats. The HTML and JSON formatters are built in; other

data/lib/simplecov/combine/methods_combiner.rb

@@ -16,14 +16,15 @@ module SimpleCov
       #
       # Method coverage maps `[class, name, start_line, start_col, end_line,
       # end_col]` keys to hit counts. Keys are matched on their SOURCE
-      # identity — (name, location), ignoring the class element — because
-      # Ruby records one entry per receiver: the same `define_method` block
-      # defined onto different classes in different processes arrives with
-      # different (normalized) receivers for the same source method, and
-      # matching on the full key would keep both, letting a never-called
-      # receiver's 0 shadow a covered method after merge (issue #1234).
-      # Combining sums the hit counts for matching methods and preserves
-      # methods that only appear in one result.
+      # identity — the location, ignoring the class and name elements —
+      # because Ruby records one entry per defined method: the same
+      # `define_method` block defined onto different classes, or under
+      # different names, in different processes arrives with different
+      # receivers or names for the same source method, and matching on the
+      # full key would keep both, letting a never-called copy's 0 shadow a
+      # covered method after merge (issue #1234). Combining sums the hit
+      # counts for matching methods and preserves methods that only appear
+      # in one result.
       #
       # @return [Hash]
       #
@@ -41,8 +42,8 @@ module SimpleCov
       end
 
       def source_identity(key)
-        _class_name, *identity = SourceFile::RubyDataParser.call(key)
-        identity
+        _class_name, _method_name, *location = SourceFile::RubyDataParser.call(key)
+        location
       end
     end
   end

data/lib/simplecov/configuration/formatting.rb

@@ -9,11 +9,16 @@ module SimpleCov
     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
+    # 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.
     #
     def formatter(formatter = :__no_arg__)
@@ -40,7 +45,8 @@ module SimpleCov
 
     # 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.
+    # where `MultiFormatter.new` normalized its input. Elements may be
+    # formatter classes or ready-built instances; see `formatter`.
     def formatters=(formatters)
       formatters = Array(formatters)
       @formatter = formatters.empty? ? nil : SimpleCov::Formatter::MultiFormatter.new(formatters)

data/lib/simplecov/formatter/multi_formatter.rb

@@ -10,7 +10,7 @@ module SimpleCov
       module InstanceMethods
         def format(result)
           formatters.map do |formatter|
-            formatter.new.format(result)
+            Formatter.instance_for(formatter).format(result)
           rescue StandardError => e
             warn("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{(_ = e.backtrace).first})")
             nil

data/lib/simplecov/formatter.rb

@@ -6,6 +6,13 @@ module SimpleCov
   # and can be wired up via `SimpleCov.formatter=`.
   # TODO: Documentation on how to build your own formatters
   module Formatter
+    # Formatters can be configured either as classes (instantiated
+    # fresh for every report) or as ready-built instances — the only
+    # way to reach constructor options like
+    # `HTMLFormatter.new(silent: true)`. See #1240.
+    def self.instance_for(formatter)
+      formatter.is_a?(Class) ? formatter.new : formatter
+    end
   end
 end
 

data/lib/simplecov/result.rb

@@ -102,7 +102,7 @@ module SimpleCov
       formatter = SimpleCov.formatter
       return nil if formatter.nil?
 
-      formatter.new.format(self)
+      Formatter.instance_for(formatter).format(self)
     end
 
     # Defines when this result has been created. Defaults to Time.now

data/lib/simplecov/result_adapter.rb

@@ -60,37 +60,69 @@ module SimpleCov
     SINGLETON_WRAPPER_PATTERN = /\A#<Class:([A-Z_][\w:]*)>\z/
     private_constant :SINGLETON_WRAPPER_PATTERN
 
-    # Ruby's method coverage records one entry per RECEIVER, not per source
-    # location: a block handed to `define_method` / `define_singleton_method`
-    # from a shared code path (a module's `included` hook, a builder) yields
-    # a separate `[receiver, name, location]` entry for every class it's
-    # defined on, all pointing at the same source. A file-based report can
-    # only express "was the method at this location ever executed", so
-    # entries are aggregated by (name, location), summing hits — otherwise
-    # each receiver whose copy never ran shows as a phantom uncovered method
-    # on a line whose line coverage is 100% (issue #1234). The first entry's
-    # (normalized) receiver is kept for display.
+    # Ruby's method coverage records one entry per DEFINED METHOD, not per
+    # source location: a block handed to `define_method` /
+    # `define_singleton_method` from a shared code path yields a separate
+    # `[receiver, name, location]` entry for every class it's defined on
+    # (a module's `included` hook defining onto each descendant) AND for
+    # every name it's defined under (a builder looping `define_method key`
+    # over a container), all pointing at the same source. A file-based
+    # report can only express "was the method at this location ever
+    # executed", so entries are aggregated by location alone, summing
+    # hits — otherwise each receiver or name whose generated copy never
+    # ran shows as a phantom uncovered method on a line whose line
+    # coverage is 100%. Regular `def`s map one location to one name, so
+    # they are unaffected. The first entry's (normalized) key is kept for
+    # display. See issue #1234.
     def normalize_method_keys(cover_statistic)
       methods = cover_statistic[:methods]
       return unless methods
 
       aggregated = {} #: Hash[untyped, [untyped, Integer]]
       methods.each_with_object(aggregated) do |(key, count), memo|
-        identity = key[1..] #: Array[untyped]
-        retained_key, existing = memo[identity] || [normalize_method_key(key), 0]
-        memo[identity] = [retained_key, existing + count]
+        location = key[2..] #: Array[untyped]
+        retained_key, existing = memo[location] || [normalize_method_key(key), 0]
+        memo[location] = [retained_key, existing + count]
       end
       cover_statistic[:methods] = aggregated.values.to_h
     end
 
     def normalize_method_key(key)
       normalized_key = key.dup
-      normalized_key[0] = key[0].to_s
-                                .gsub(ADDRESS_PATTERN, ADDRESS_PLACEHOLDER)
-                                .sub(SINGLETON_WRAPPER_PATTERN, '\1')
+      normalized_key[0] = class_display_name(key[0])
+                          .gsub(ADDRESS_PATTERN, ADDRESS_PLACEHOLDER)
+                          .sub(SINGLETON_WRAPPER_PATTERN, '\1')
       normalized_key
     end
 
+    # Rendering a class name can execute user code: a singleton class's
+    # `to_s` renders its attached object via `#inspect`, which a module can
+    # shadow with an incompatible signature (Liquid::Utils defines
+    # `inspect(value, max_depth = 2)` as a module_function, so rendering
+    # `#<Class:Liquid::Utils>` raises ArgumentError). A coverage report
+    # must never crash the host suite over that, so on failure rebuild the
+    # singleton wrapper from `Module#name` via bound methods (which cannot
+    # be shadowed), falling back to the address form, which
+    # ADDRESS_PATTERN then normalizes. See issue #1236.
+    def class_display_name(klass)
+      klass.to_s
+    rescue StandardError
+      singleton_wrapper_name(klass) || Object.instance_method(:to_s).bind_call(klass)
+    end
+
+    def singleton_wrapper_name(klass)
+      return nil unless klass.is_a?(Class) && klass.singleton_class?
+
+      attached = klass.attached_object
+      # simplecov:disable branch — CRuby only reaches the rescue via a
+      # Module/Class attached object (instance singletons render from the
+      # class name chain without calling user inspect), so the non-Module
+      # arm is defensive.
+      name = Module.instance_method(:name).bind_call(attached) if attached.is_a?(Module)
+      # simplecov:enable branch
+      name && "#<Class:#{name}>"
+    end
+
     # Ruby's eval coverage records a fresh set of branch entries for every
     # COMPILE of an eval'd string: a template rendered through multiple view
     # classes (e.g. hanami-view compiles each template once per view) yields

data/lib/simplecov/source_file/ruby_data_parser.rb

@@ -15,10 +15,28 @@ module SimpleCov
 
       # Tests use the real data structures (except for integration tests)
       # so no need to put them through here.
+      #
+      # String parses are memoized: `Combine::BranchesCombiner` and
+      # `Combine::MethodsCombiner` derive a merge identity from every key of
+      # both sides on every pairwise merge, so collating N resultsets parses
+      # each key string N-1 times — and Ripper dominates the wall time of a
+      # large collate.
+      # Key strings repeat across folds and within report building, while the
+      # set of unique keys is bounded by the project's branch and method
+      # count, so a permanent cache stays small. Cached arrays are frozen
+      # element-wise (String class names included, not just the tuple):
+      # every caller destructures without mutating, and sharing one array
+      # across callers must stay that way. The cache key needs no such
+      # care — `Hash#[]=` dups and freezes String keys on its own.
       def call(structure)
         return structure if structure.is_a?(Array)
 
-        parse_array_string(structure.to_s)
+        string = structure.to_s
+        parse_cache[string] ||= parse_array_string(string).each(&:freeze).freeze
+      end
+
+      def parse_cache
+        @parse_cache ||= {} #: Hash[String, untyped]
       end
 
       # Parse a string like '[:if, 0, 3, 4, 3, 21]' or

data/lib/simplecov/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  VERSION = "1.0.2"
+  VERSION = "1.0.3"
 end

data/sig/simplecov.rbs

@@ -1217,13 +1217,18 @@ end
 module SimpleCov
   # Namespace for result formatters. A formatter is any class whose
   # instances respond to `#format(result)` and that can be instantiated
-  # with no arguments; wire one up via `SimpleCov.formatter=` or
+  # with no arguments, or a ready-built instance responding to
+  # `#format(result)`; wire one up via `SimpleCov.formatter=` or
   # `SimpleCov.formatters=`.
   module Formatter
     # Structural interface for custom formatter instances.
     interface _Formatter
       def format: (SimpleCov::Result result) -> untyped
     end
+
+    # Normalizes a configured formatter — class or ready-built
+    # instance — into an instance. See #1240.
+    def self.instance_for: (untyped formatter) -> untyped
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simplecov
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Erik Berlin
@@ -154,9 +154,9 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/simplecov-ruby/simplecov/issues
   changelog_uri: https://github.com/simplecov-ruby/simplecov/blob/main/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/simplecov/1.0.2
+  documentation_uri: https://www.rubydoc.info/gems/simplecov/1.0.3
   mailing_list_uri: https://groups.google.com/forum/#!forum/simplecov
-  source_code_uri: https://github.com/simplecov-ruby/simplecov/tree/v1.0.2
+  source_code_uri: https://github.com/simplecov-ruby/simplecov/tree/v1.0.3
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -172,7 +172,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.17
 specification_version: 4
 summary: Code coverage for Ruby
 test_files: []