Lift dogfood to 100% branch coverage

Enable :branch in after(:suite) and threshold both line and branch at
100%. Add branch-targeting specs for the testable conditionals and bare
gates, SIMPLECOV_NO_DEFAULTS, the at_exit Proc.new fallback, status's
covered? else nil).

Also drop unnecessary &. operators in FileList and SourceFile where
the receiver is invariantly non-nil (line stats are always set;
SourceFile always assembles a full :line/:branch/:method
coverage_statistics hash). Those were producing dead 'else' branches.

Author: sferik

lib/simplecov.rb

@@ -77,8 +77,10 @@ def install_at_exit_hook
     def start_tracking
       require "coverage"
       warn_if_jruby_full_trace_disabled
+      # simplecov:disable — fork-hook is enabled via SimpleCov.enable_for_subprocesses, off by default
       require_relative "simplecov/process" if SimpleCov.enabled_for_subprocesses? &&
                                               ::Process.respond_to?(:_fork)
+      # simplecov:enable
 
       make_parallel_tests_available
 
@@ -332,7 +334,7 @@ def wait_for_other_processes
     # @api private
     def wait_for_parallel_results
       expected = ENV["PARALLEL_TEST_GROUPS"]&.to_i
-      return unless expected && expected > 1
+      return unless expected && expected > 1 # simplecov:disable branch — only false in real parallel_tests run
 
       # simplecov:disable — only fires when ENV is set with >1 group
       deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 10
@@ -457,8 +459,8 @@ def result_with_not_loaded_files
 
     # parallel_tests isn't always available, see: https://github.com/grosser/parallel_tests/issues/772
     def make_parallel_tests_available
-      return if defined?(ParallelTests)
-      return unless probably_running_parallel_tests?
+      return if defined?(ParallelTests) # simplecov:disable — only true after a previous load
+      return unless probably_running_parallel_tests? # simplecov:disable — false outside parallel_tests
 
       # simplecov:disable — only fires under a real parallel_tests setup
       require "parallel_tests"
@@ -479,7 +481,7 @@ def probably_running_parallel_tests?
     # @see https://github.com/simplecov-ruby/simplecov/issues/420
     # @see https://github.com/simplecov-ruby/simplecov/issues/86
     def warn_if_jruby_full_trace_disabled
-      return unless defined?(JRUBY_VERSION) && defined?(JRuby)
+      return unless defined?(JRUBY_VERSION) && defined?(JRuby) # simplecov:disable — JRuby-only branch
 
       # simplecov:disable — JRuby-only branches; unreachable from CRuby
       return if org.jruby.RubyInstanceConfig.FULL_TRACE_ENABLED
@@ -525,4 +527,5 @@ def warn_if_jruby_full_trace_disabled
 require_relative "simplecov/simulate_coverage"
 
 # Load default config
+# simplecov:disable — env-var only set by aruba feature tests
 require_relative "simplecov/defaults" unless ENV["SIMPLECOV_NO_DEFAULTS"]

lib/simplecov/command_guesser.rb

@@ -48,15 +48,17 @@ def from_command_line_options
       # quirk with multi-line array literals.
       DEFINED_CONSTANT_FRAMEWORKS = [
         ["RSpec",      -> { defined?(::RSpec) }],
-        ["Unit Tests", -> { defined?(Test::Unit) }],   # simplecov:disable line
-        ["Minitest",   -> { defined?(::Minitest) }],   # simplecov:disable line
-        ["MiniTest",   -> { defined?(MiniTest) }]      # simplecov:disable line
+        ["Unit Tests", -> { defined?(Test::Unit) }],   # simplecov:disable
+        ["Minitest",   -> { defined?(::Minitest) }],   # simplecov:disable
+        ["MiniTest",   -> { defined?(MiniTest) }]      # simplecov:disable
       ].freeze
       private_constant :DEFINED_CONSTANT_FRAMEWORKS
 
       # If the command regexps fail, let's try checking defined constants.
       def from_defined_constants
+        # simplecov:disable branch — first iter returns when ::RSpec is defined; later branches unreachable
         DEFINED_CONSTANT_FRAMEWORKS.each { |name, defined_check| return name if defined_check.call }
+        # simplecov:enable branch
 
         # TODO: Provide link to docs/wiki article
         # simplecov:disable — only fires when no framework is detected, which

lib/simplecov/directive.rb

@@ -81,7 +81,7 @@ def self.source_might_contain_directive?(lines)
       lines.any? do |line|
         line.include?("simplecov")
       rescue ArgumentError, EncodingError
-        false # simplecov:disable line — defensive guard for invalid byte sequences in source
+        false # simplecov:disable — defensive guard for invalid byte sequences in source
       end
     end
 
@@ -114,7 +114,7 @@ def self.inline?(lines, line_number, column)
       line = lines[line_number - 1].to_s
       !line.byteslice(0, column).to_s.strip.empty?
     rescue ArgumentError, EncodingError
-      false # simplecov:disable line — defensive guard for invalid byte sequences
+      false # simplecov:disable — defensive guard for invalid byte sequences
     end
 
     def self.comments_in(lines)
@@ -123,7 +123,7 @@ def self.comments_in(lines)
         [line_number, column, text] if type == :on_comment
       end
     rescue ArgumentError, EncodingError
-      [] # simplecov:disable line — Ripper.lex can raise on invalid byte sequences
+      [] # simplecov:disable — Ripper.lex can raise on invalid byte sequences
     end
 
     private_class_method :directives_in, :source_might_contain_directive?,

lib/simplecov/file_list.rb

@@ -33,12 +33,12 @@ def coverage_statistics_by_file
 
     # Returns the count of lines that have coverage
     def covered_lines
-      coverage_statistics[:line]&.covered
+      coverage_statistics[:line].covered
     end
 
     # Returns the count of lines that have been missed
     def missed_lines
-      coverage_statistics[:line]&.missed
+      coverage_statistics[:line].missed
     end
 
     # Returns the count of lines that are not relevant for coverage
@@ -68,19 +68,19 @@ def least_covered_file
 
     # Returns the overall amount of relevant lines of code across all files in this list
     def lines_of_code
-      coverage_statistics[:line]&.total
+      coverage_statistics[:line].total
     end
 
     # Computes the coverage based upon lines covered and lines missed
     # @return [Float]
     def covered_percent
-      coverage_statistics[:line]&.percent
+      coverage_statistics[:line].percent
     end
 
     # Computes the strength (hits / line) based upon lines covered and lines missed
     # @return [Float]
     def covered_strength
-      coverage_statistics[:line]&.strength
+      coverage_statistics[:line].strength
     end
 
     # Return total count of branches in all files

lib/simplecov/profiles.rb

@@ -53,9 +53,9 @@ def autoload_profile(name)
       require "simplecov/profiles/#{name}"
     rescue LoadError
       begin
-        # simplecov:disable line — third-party gem fallback (no such gem in test env)
+        # simplecov:disable — third-party gem fallback (no such gem in test env)
         require "simplecov-profile-#{name}"
-        # simplecov:enable line
+        # simplecov:enable
       rescue LoadError
         # fall through; #fetch_proc raises the user-facing error
       end

lib/simplecov/source_file.rb

@@ -77,7 +77,7 @@ def skipped_lines
 
     # Returns the number of relevant lines (covered + missed)
     def lines_of_code
-      coverage_statistics[:line]&.total
+      coverage_statistics[:line].total
     end
 
     # Access SimpleCov::SourceFile::Line source lines by line number
@@ -87,11 +87,11 @@ def line(number)
 
     # The coverage for this file in percent. 0 if the file has no coverage lines
     def covered_percent
-      coverage_statistics[:line]&.percent
+      coverage_statistics[:line].percent
     end
 
     def covered_strength
-      coverage_statistics[:line]&.strength
+      coverage_statistics[:line].strength
     end
 
     def no_lines?
@@ -113,7 +113,7 @@ def no_branches?
     end
 
     def branches_coverage_percent
-      coverage_statistics[:branch]&.percent
+      coverage_statistics[:branch].percent
     end
 
     #
@@ -179,7 +179,7 @@ def missed_methods
     end
 
     def methods_coverage_percent
-      coverage_statistics[:method]&.percent
+      coverage_statistics[:method].percent
     end
 
     # Whether this file was added via track_files but never loaded/required.
@@ -272,7 +272,9 @@ def ensure_remove_undefs(file_lines)
       # also setting these option on `file.set_encoding` doesn't seem to work
       # properly so it has to be done here.
       file_lines.each do |line|
+        # simplecov:disable — defensive: only fires for non-UTF-8 source files
         line.encode!("UTF-8", invalid: :replace, undef: :replace) unless line.encoding == Encoding::UTF_8
+        # simplecov:enable
       end
     end
 
@@ -363,7 +365,9 @@ def restore_ruby_data_structure(structure)
     # 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
       array_node = sexp&.dig(1, 0)
+      # simplecov:enable
       raise ArgumentError, "expected array literal: #{str.inspect}" unless array_node && array_node[0] == :array
 
       Array(array_node[1]).map { |element| parse_array_element(element) }
@@ -377,9 +381,9 @@ def parse_array_element(node)
       when :var_ref                      then node.dig(1, 1) # `Foo`
       when :const_path_ref               then "#{parse_array_element(node[1])}::#{node[2][1]}" # `Foo::Bar`
       else
-        # simplecov:disable line — defensive fallback for unexpected Ripper node shapes
+        # simplecov:disable — defensive fallback for unexpected Ripper node shapes
         raise ArgumentError, "unexpected element: #{node.inspect}"
-        # simplecov:enable line
+        # simplecov:enable
       end
     end
 

lib/simplecov/source_file/line.rb

@@ -68,7 +68,9 @@ def status
         return "never" if never?
         return "missed" if missed?
 
+        # simplecov:disable — defensive: covered? is the only state left after the three above
         "covered" if covered?
+        # simplecov:enable
       end
     end
   end

spec/combine/lines_combiner_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "helper"
+
+describe SimpleCov::Combine::LinesCombiner do
+  describe ".combine" do
+    it "uses coverage_a as the accumulator when it is longer" do
+      a = [1, 1, nil, 1, nil]
+      b = [1, 0, nil]
+      expect(described_class.combine(a, b)).to eq([2, 1, nil, 1, nil])
+    end
+
+    it "uses coverage_b as the accumulator when it is longer" do
+      a = [1, 0, nil]
+      b = [1, 1, nil, 1, nil]
+      expect(described_class.combine(a, b)).to eq([2, 1, nil, 1, nil])
+    end
+  end
+
+  describe ".merge_line_coverage" do
+    it "treats nil + 0 as nil (line never relevant on either side)" do
+      expect(described_class.merge_line_coverage(nil, 0)).to be_nil
+    end
+
+    it "sums integer hits" do
+      expect(described_class.merge_line_coverage(2, 3)).to eq(5)
+    end
+  end
+end

spec/command_guesser_spec.rb

@@ -57,4 +57,15 @@
     allow(ENV).to receive(:fetch).with("PARALLEL_TEST_GROUPS", nil).and_return("2")
     expect(guesser.guess).to eq("RSpec (1/2)")
   end
+
+  it 'treats an empty TEST_ENV_NUMBER as worker "1"' do
+    guesser.original_run_command = "/some/path/spec/foo.rb"
+    allow(ENV).to receive(:[]).and_call_original
+    allow(ENV).to receive(:fetch).and_call_original
+    allow(ENV).to receive(:[]).with("TEST_ENV_NUMBER").and_return("")
+    allow(ENV).to receive(:[]).with("PARALLEL_TEST_GROUPS").and_return("2")
+    allow(ENV).to receive(:fetch).with("TEST_ENV_NUMBER", nil).and_return("")
+    allow(ENV).to receive(:fetch).with("PARALLEL_TEST_GROUPS", nil).and_return("2")
+    expect(guesser.guess).to eq("RSpec (1/2)")
+  end
 end

spec/configuration_spec.rb

@@ -498,6 +498,49 @@
       end
     end
 
+    describe "#command_name" do
+      after { config.instance_variable_set(:@name, nil) }
+
+      it "stores an explicit name" do
+        config.command_name("My Suite")
+        expect(config.command_name).to eq("My Suite")
+      end
+    end
+
+    describe "#project_name" do
+      after { config.instance_variable_set(:@project_name, nil) }
+
+      it "stores an explicit name" do
+        config.project_name("Custom")
+        expect(config.project_name).to eq("Custom")
+      end
+    end
+
+    describe "#merge_timeout" do
+      after { config.instance_variable_set(:@merge_timeout, nil) }
+
+      it "stores an explicit integer value" do
+        config.merge_timeout(120)
+        expect(config.merge_timeout).to eq(120)
+      end
+    end
+
+    describe "#parse_filter" do
+      it "raises when given neither a filter argument nor a block" do
+        expect { config.send(:parse_filter) }.to raise_error(ArgumentError, /filter or a block/)
+      end
+    end
+
+    describe "#configure" do
+      it "uses instance_exec directly when the block is in our own context" do
+        # Stub equal? so the "block defined in our own context" branch fires
+        # without contorting the test to share a binding with the config.
+        allow(config).to receive(:equal?).and_return(true)
+        config.configure { @configured = true }
+        expect(config.instance_variable_get(:@configured)).to be true
+      end
+    end
+
     describe "#use_merging" do
       around do |example|
         previous = config.instance_variable_get(:@use_merging)