Lift dogfood to 100% method coverage

Enable :method in after(:suite) and threshold all three criteria.

Two real fixes fell out: restore SourceFile#parse_ruby_array_string's
'try plain Ripper, then pre-quote on failure' approach (method-coverage
keys for simplecov-on-simplecov take the form
["#<Class:SimpleCov>", :name, ...] — valid Ruby with the wrapper
inside a quoted string), and merge singleton + instance method-coverage
keys in ResultAdapter#normalize_method_keys (Ruby's Coverage records
module_function methods twice; only one form is reachable, so the
other was always 0).

Author: sferik

lib/simplecov/result_adapter.rb

@@ -43,18 +43,29 @@ def adapt
     ADDRESS_PLACEHOLDER = "0x0"
     private_constant :ADDRESS_PLACEHOLDER
 
+    # Strip the `#<Class:Foo>` wrapper Ruby's Coverage adds to singleton-class
+    # method keys. `module_function` and class methods get recorded both as
+    # singleton (`[#<Class:Foo>, :m, …]`) and instance/module (`[Foo, :m, …]`)
+    # entries pointing at the same source location; only one of the two is
+    # ever reachable at runtime, so we merge them. Only applies to named
+    # constants — anonymous-class addresses like `#<Class:0x0>` are left
+    # alone (handled by ADDRESS_PATTERN above).
+    SINGLETON_WRAPPER_PATTERN = /\A#<Class:([A-Z_][\w:]*)>\z/
+    private_constant :SINGLETON_WRAPPER_PATTERN
+
     def normalize_method_keys(cover_statistic)
       methods = cover_statistic[:methods]
       return unless methods
 
-      normalized = {}
-      methods.each do |key, count|
+      cover_statistic[:methods] = methods.each_with_object({}) do |(key, count), normalized|
         normalized_key = key.dup
-        normalized_key[0] = normalized_key[0].to_s.gsub(ADDRESS_PATTERN, ADDRESS_PLACEHOLDER)
-        # Keys might collide after normalization (two anonymous classes with same method)
+        normalized_key[0] = key[0].to_s
+                                  .gsub(ADDRESS_PATTERN, ADDRESS_PLACEHOLDER)
+                                  .sub(SINGLETON_WRAPPER_PATTERN, '\1')
+        # Keys may collide after normalization (anonymous classes sharing a
+        # method name, or singleton + instance forms of a module_function method).
         normalized[normalized_key] = normalized.fetch(normalized_key, 0) + count
       end
-      cover_statistic[:methods] = normalized
     end
 
     def adapt_oneshot_lines_if_needed(file_name, cover_statistic)

lib/simplecov/source_file.rb

@@ -364,8 +364,12 @@ def restore_ruby_data_structure(structure)
     # Ripper to walk the literal so we don't need to hand-roll a scanner
     # for symbols, strings, integers, and constant paths.
     def parse_ruby_array_string(str)
-      sexp = Ripper.sexp(quote_inspected_class_segments(str))
-      # simplecov:disable — defensive: Ripper.sexp returning nil requires malformed input
+      # Try plain Ripper first; only pre-quote `#<...>` inspect segments
+      # if the input isn't already valid Ruby (otherwise we corrupt
+      # `"#<Class:Foo>"` strings that *are* valid Ruby literals — exactly
+      # the shape simplecov-on-simplecov method-coverage keys take).
+      sexp = Ripper.sexp(str) || Ripper.sexp(quote_inspected_class_segments(str))
+      # simplecov:disable — defensive: Ripper.sexp returning nil from both passes requires malformed input
       array_node = sexp&.dig(1, 0)
       # simplecov:enable
       raise ArgumentError, "expected array literal: #{str.inspect}" unless array_node && array_node[0] == :array

spec/helper.rb

@@ -6,7 +6,19 @@
 # dependency's behaviour around Coverage is being investigated.
 unless ENV["SIMPLECOV_NO_DOGFOOD"]
   require "coverage"
-  Coverage.start(lines: true, branches: true)
+  # Build the criteria hash by what the runtime actually supports — JRuby
+  # silently ignores `branches:`/`methods:` (with warnings); some engines
+  # may reject them outright. CRuby is the primary target so its full
+  # set is always on.
+  start_args = {lines: true}
+  if Coverage.respond_to?(:supported?)
+    start_args[:branches] = true if Coverage.supported?(:branches)
+    start_args[:methods]  = true if Coverage.supported?(:methods)
+  else
+    start_args[:branches] = true
+    start_args[:methods]  = true
+  end
+  Coverage.start(start_args)
 end
 
 require "rspec"
@@ -38,19 +50,20 @@
       raw = SimpleCov::UselessResultsRemover.call(Coverage.result)
       adapted = SimpleCov::ResultAdapter.call(raw)
 
-      # Enabling :branch is what teaches FileList / Result to surface
-      # the branch data in coverage_statistics. We enable it here
-      # (rather than in SimpleCov.start) to avoid leaking branch-mode
-      # output shape into formatter specs that assert against
-      # line-only fixtures.
+      # Enabling :branch / :method is what teaches FileList / Result
+      # to surface those data in coverage_statistics. We enable here
+      # (rather than in SimpleCov.start) to avoid leaking the
+      # multi-criterion output shape into formatter specs that assert
+      # against line-only fixtures.
       SimpleCov.enable_coverage :branch if SimpleCov.branch_coverage_supported?
+      SimpleCov.enable_coverage :method if SimpleCov.method_coverage_supported?
       result = SimpleCov::Result.new(adapted, filters: SimpleCov.filters + extra_filters, groups: {})
 
       SimpleCov::Formatter::HTMLFormatter.new(silent: true, output_dir: DOGFOOD_OUTPUT_DIR).format(result)
 
       shortfalls = []
       stats = result.coverage_statistics
-      %i[line branch].each do |criterion|
+      %i[line branch method].each do |criterion|
         actual = stats[criterion]&.percent
         next if actual.nil? || actual >= DOGFOOD_MINIMUM_COVERAGE
 

spec/result_adapter_spec.rb

@@ -123,6 +123,26 @@
       end
     end
 
+    context "with module_function double-counting (singleton + instance forms)" do
+      let(:result_set) do
+        {
+          existing_file => {
+            methods: {
+              ["#<Class:SimpleCov::Combine>", :combine, 16, 4, 20, 7] => 5,
+              [SimpleCov::Combine, :combine, 16, 4, 20, 7] => 0
+            }
+          }
+        }
+      end
+
+      it "merges singleton and instance entries into a single key with combined hits" do
+        methods = adapter[existing_file][:methods]
+        expect(methods.keys.size).to eq(1)
+        expect(methods.keys.first[0]).to eq("SimpleCov::Combine")
+        expect(methods.values.first).to eq(5)
+      end
+    end
+
     context "with two distinct anonymous classes that share a method" do
       let(:result_set) do
         {