Tighten remaining Ruby helpers

Use Hash#slice, ENV.values_at, Array#size, and compact glob assembly
where they express the same work directly. Build grouped-file membership
as a Set so ungrouped detection stays linear.

Rename the root regexp helper while keeping the legacy root_regx shim,
refresh it when SimpleCov.root changes, and update the focused specs
around the new helper shapes.

Author: sferik

lib/simplecov/command_guesser.rb

@@ -22,8 +22,7 @@ def guess
       # When parallel_tests (or a compatible runner) is driving the suite,
       # tag the command name with this worker's position in the pool.
       def parallel_data
-        groups = ENV.fetch("PARALLEL_TEST_GROUPS", nil)
-        number = ENV.fetch("TEST_ENV_NUMBER", nil)
+        groups, number = ENV.values_at("PARALLEL_TEST_GROUPS", "TEST_ENV_NUMBER")
         return unless groups && number
 
         # parallel_tests sets the first worker's TEST_ENV_NUMBER to "" rather

lib/simplecov/file_list.rb

@@ -45,14 +45,14 @@ def missed_lines
     def never_lines
       return 0.0 if empty?
 
-      sum { |f| f.never_lines.count }
+      sum { |f| f.never_lines.size }
     end
 
     # Returns the count of skipped lines
     def skipped_lines
       return 0.0 if empty?
 
-      sum { |f| f.skipped_lines.count }
+      sum { |f| f.skipped_lines.size }
     end
 
     # Computes the coverage based upon lines covered and lines missed for each file

lib/simplecov/formatter/json_formatter/source_file_formatter.rb

@@ -37,8 +37,8 @@ def ensure_utf8(str)
         end
 
         def line_coverage_section
-          covered = @source_file.covered_lines.count
-          missed = @source_file.missed_lines.count
+          covered = @source_file.covered_lines.size
+          missed = @source_file.missed_lines.size
           {
             lines: @source_file.lines.map { |line| format_line(line) },
             lines_covered_percent: @source_file.covered_percent,
@@ -52,19 +52,19 @@ def branch_coverage_section
           {
             branches: @source_file.branches.map { |branch| format_branch(branch) },
             branches_covered_percent: @source_file.branches_coverage_percent,
-            covered_branches: @source_file.covered_branches.count,
-            missed_branches: @source_file.missed_branches.count,
-            total_branches: @source_file.total_branches.count
+            covered_branches: @source_file.covered_branches.size,
+            missed_branches: @source_file.missed_branches.size,
+            total_branches: @source_file.total_branches.size
           }
         end
 
         def method_coverage_section
           {
             methods: @source_file.methods.map { |method| format_method(method) },
             methods_covered_percent: @source_file.methods_coverage_percent,
-            covered_methods: @source_file.covered_methods.count,
-            missed_methods: @source_file.missed_methods.count,
-            total_methods: @source_file.methods.count
+            covered_methods: @source_file.covered_methods.size,
+            missed_methods: @source_file.missed_methods.size,
+            total_methods: @source_file.methods.size
           }
         end
 

lib/simplecov/profiles/root_filter.rb

@@ -6,6 +6,6 @@
   # place; this profile is the user-facing entry point that tools like
   # `SimpleCov.filtered` apply.
   skip do |src|
-    src.filename !~ SimpleCov::UselessResultsRemover.root_regx
+    src.filename !~ SimpleCov::UselessResultsRemover.root_regex
   end
 end

lib/simplecov/result.rb

@@ -132,8 +132,7 @@ def warn_about_missing_source_files(missing, input_size)
     end
 
     def coverage
-      keys = original_result.keys & filenames
-      keys.zip(original_result.values_at(*keys)).to_h
+      original_result.slice(*filenames)
     end
 
     # Applies the given filter chain to `@files`, dropping each source

lib/simplecov/result_processing.rb

@@ -67,7 +67,7 @@ def grouped(files)
         SimpleCov::FileList.new(files.select { |source_file| filter.matches?(source_file) })
       end
 
-      in_group  = grouped.values.flat_map(&:to_a)
+      in_group  = grouped_file_set(grouped)
       ungrouped = files.reject { |source_file| in_group.include?(source_file) }
       grouped["Ungrouped"] = SimpleCov::FileList.new(ungrouped) if ungrouped.any?
 
@@ -104,6 +104,10 @@ def initial_setup(profile, &block)
       configure(&block) if block
     end
 
+    def grouped_file_set(grouped)
+      grouped.values.each_with_object(Set.new) { |file_list, set| set.merge(file_list) }
+    end
+
     # Finds files that were to be tracked but were not loaded, and
     # initializes their line-by-line coverage to zero (or nil for
     # comments / whitespace).
@@ -119,10 +123,7 @@ def add_not_loaded_files(result)
     # with every string glob declared via `cover` (also restrictive,
     # but the restriction lives in `Result#apply_cover_filters!`).
     def unloaded_file_discovery_globs
-      globs = []
-      globs << tracked_files if tracked_files
-      globs.concat(cover_globs)
-      globs
+      [tracked_files, *cover_globs].compact
     end
 
     # Expand the given globs relative to SimpleCov.root, not Dir.pwd —

lib/simplecov/useless_results_remover.rb

@@ -7,13 +7,21 @@ module SimpleCov
   # run never make it into the formatted result.
   module UselessResultsRemover
     def self.call(coverage_result)
-      coverage_result.select { |path, _coverage| path.match?(root_regx) }
+      coverage_result.select { |path, _coverage| path.match?(root_regex) }
     end
 
     # The `/i` flag covers case-insensitive matches on Windows / macOS-HFS+
     # where the on-disk path's case can differ from `SimpleCov.root`'s.
+    def self.root_regex
+      root = SimpleCov.root
+      return @root_regex if root == @root_regex_root
+
+      @root_regex_root = root
+      @root_regex = /\A#{Regexp.escape(root.chomp(File::SEPARATOR) + File::SEPARATOR)}/i
+    end
+
     def self.root_regx
-      @root_regx ||= /\A#{Regexp.escape(SimpleCov.root.chomp(File::SEPARATOR) + File::SEPARATOR)}/i
+      root_regex
     end
   end
 end

spec/command_guesser_spec.rb

@@ -62,23 +62,19 @@
 
   it "appends parallel data" 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("1")
-    allow(ENV).to receive(:[]).with("PARALLEL_TEST_GROUPS").and_return("2")
-    allow(ENV).to receive(:fetch).with("TEST_ENV_NUMBER", nil).and_return("1")
-    allow(ENV).to receive(:fetch).with("PARALLEL_TEST_GROUPS", nil).and_return("2")
+    allow(ENV).to receive(:values_at).and_call_original
+    allow(ENV).to receive(:values_at)
+      .with("PARALLEL_TEST_GROUPS", "TEST_ENV_NUMBER")
+      .and_return(%w[2 1])
     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")
+    allow(ENV).to receive(:values_at).and_call_original
+    allow(ENV).to receive(:values_at)
+      .with("PARALLEL_TEST_GROUPS", "TEST_ENV_NUMBER")
+      .and_return(["2", ""])
     expect(guesser.guess).to eq("RSpec (1/2)")
   end
 end

spec/useless_results_remover_spec.rb

@@ -33,17 +33,19 @@
     expect(remover[source_path]["lines"]).to be_a(Array)
   end
 
+  it "keeps the legacy root_regx helper as an alias" do
+    expect(described_class.root_regx).to eq(described_class.root_regex)
+  end
+
   context "when SimpleCov.root is the filesystem root" do
     around do |example|
       skip "filesystem root semantics are Unix-only" if Gem.win_platform?
 
       previous_root = SimpleCov.root
-      described_class.instance_variable_set(:@root_regx, nil)
       SimpleCov.root("/")
       example.run
     ensure
       SimpleCov.root(previous_root)
-      described_class.instance_variable_set(:@root_regx, nil)
     end
 
     let(:result_set) do