Use coverage dup for statistics aggregation

Author: samuel-williams-shopify

lib/covered/coverage.rb

@@ -51,6 +51,16 @@ def initialize(source, counts = [], annotations = {})
 			@annotations = annotations
 		end
 
+		# Initialize a copy of this coverage object.
+		# @parameter other [Covered::Coverage] The coverage object to copy.
+		def initialize_copy(other)
+			super
+			
+			@source = other.source.dup
+			@counts = other.counts.dup
+			@annotations = other.annotations.transform_values(&:dup)
+		end
+		
 		# @attribute [Covered::Source] The covered source metadata.
 		attr_accessor :source
 

lib/covered/statistics.rb

@@ -24,36 +24,29 @@ def self.for(coverage)
 			end
 		end
 
-		# Immutable aggregate coverage statistics.
+		# Aggregate coverage totals.
 		class Aggregate
 			include Ratio
 
-			# Initialize aggregate statistics from coverage objects.
+			# Build aggregate statistics from coverage objects.
 			# @parameter coverages [Enumerable(Covered::Coverage)] The coverage objects to summarize.
-			def initialize(coverages = [])
-				paths = Hash.new
-				
-				coverages.each do |coverage|
-					current = paths[coverage.path]
-					
-					unless current
-						current = paths[coverage.path] = coverage.empty
+			# @returns [Covered::Statistics::Aggregate] The aggregate statistics.
+			def self.for(coverages)
+				self.new.tap do |aggregate|
+					coverages.each do |coverage|
+						aggregate << coverage
 					end
-					
-					current.merge!(coverage)
 				end
-				
-				paths.each_value(&:freeze)
-				
-				@count = paths.size
-				@executable_count = paths.sum{|_path, coverage| coverage.executable_count}
-				@executed_count = paths.sum{|_path, coverage| coverage.executed_count}
-				
-				freeze
 			end
 
-			# Total number of files added.
-			# @returns [Integer] The number of covered files.
+			# Initialize empty aggregate statistics.
+			def initialize
+				@count = 0
+				@executable_count = 0
+				@executed_count = 0
+			end
+			
+			# @attribute [Integer] The total number of coverage instances added.
 			attr :count
 
 			# The number of lines which could have been executed.
@@ -81,6 +74,18 @@ def as_json
 			def to_json(options)
 				as_json.to_json(options)
 			end
+			
+			# Add coverage to these aggregate statistics.
+			# @parameter coverage [Covered::Coverage] The coverage object to add.
+			# @returns [Covered::Statistics::Aggregate] This aggregate.
+			def << coverage
+				@count += 1
+				
+				@executable_count += coverage.executable_count
+				@executed_count += coverage.executed_count
+				
+				self
+			end
 		end
 
 		# Initialize empty coverage statistics.
@@ -92,7 +97,7 @@ def initialize
 		# The total aggregate statistics.
 		# @returns [Covered::Statistics::Aggregate] The total aggregate statistics.
 		def total
-			@total ||= Aggregate.new(@paths.values)
+			@total ||= Aggregate.for(@paths.values)
 		end
 
 		# @attribute [Hash(String, Covered::Coverage)] Coverage statistics indexed by path.
@@ -119,17 +124,17 @@ def executed_count
 		# Add coverage to these statistics.
 		# @parameter coverage [Covered::Coverage] The coverage object to add.
 		def << coverage
-			current = @paths[coverage.path]
-			
-			unless current
-				current = @paths[coverage.path] = coverage.empty
+			if current = @paths[coverage.path]
+				current.merge!(coverage)
+				
+				@total = nil
+			else
+				coverage = @paths[coverage.path] = coverage.dup
+				
+				@total << coverage if @total
 			end
 
-			current.merge!(coverage)
-			
-			@total = nil
-			
-			return self
+			self
 		end
 
 		# Get coverage for the given path.

test/covered/coverage.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2018-2025, by Samuel Williams.
+
+require "covered/coverage"
+
+describe Covered::Coverage do
+	let(:source) {Covered::Source.new("foo.rb")}
+	let(:coverage) {subject.new(source, [nil, 1], 1 => ["covered"])}
+	
+	it "can be duplicated" do
+		copy = coverage.dup
+		
+		expect(copy.equal?(coverage)).to be == false
+		expect(copy.source.equal?(coverage.source)).to be == false
+		expect(copy.counts).to be == coverage.counts
+		expect(copy.counts.equal?(coverage.counts)).to be == false
+		expect(copy.annotations).to be == coverage.annotations
+		expect(copy.annotations.equal?(coverage.annotations)).to be == false
+		expect(copy.annotations[1].equal?(coverage.annotations[1])).to be == false
+	end
+	
+	it "does not share mutable state with duplicates" do
+		copy = coverage.dup
+		
+		copy.mark(2, 1)
+		copy.annotate(1, "copy")
+		copy.path = "copy.rb"
+		
+		expect(coverage.path).to be == "foo.rb"
+		expect(coverage.counts).to be == [nil, 1]
+		expect(coverage.annotations).to be == {1 => ["covered"]}
+	end
+end

test/covered/statistics.rb

@@ -83,18 +83,53 @@ def before
 	with "after reading total before adding coverage" do
 		let(:partial_coverage) {Covered::Coverage.new(source, [nil, 1, 0])}
 		let(:complete_coverage) {Covered::Coverage.new(source, [nil, 0, 1])}
+		let(:other_coverage) {Covered::Coverage.new(Covered::Source.new("bar.rb"), [nil, 1])}
 
-		def before
+		it "adds new paths to cached totals" do
 			statistics << partial_coverage
-			statistics.total
-			statistics << complete_coverage
-			super
+			
+			total = statistics.total
+			
+			statistics << other_coverage
+			
+			expect(statistics.total).to be_equal(total)
+			expect(statistics.count).to be == 2
+			expect(statistics.executable_count).to be == 3
+			expect(statistics.executed_count).to be == 2
 		end
 
 		it "invalidates cached totals" do
+			statistics << partial_coverage
+			
+			total = statistics.total
+			
 			expect(statistics.count).to be == 1
 			expect(statistics.executable_count).to be == 2
 			expect(statistics.executed_count).to be == 1
+			expect(statistics.total).to be_equal(total)
+			
+			statistics << complete_coverage
+			
+			expect(statistics.total).not.to be_equal(total)
+			expect(statistics.count).to be == 1
+			expect(statistics.executable_count).to be == 2
+			expect(statistics.executed_count).to be == 2
+		end
+	end
+	
+	with "after adding coverage" do
+		let(:coverage) {Covered::Coverage.new(source, [nil, 1])}
+		
+		it "does not share mutable state with the original coverage" do
+			statistics << coverage
+			
+			coverage.mark(2, 1)
+			coverage.path = "bar.rb"
+			
+			expect(statistics.count).to be == 1
+			expect(statistics["foo.rb"].counts).to be == [nil, 1]
+			expect(statistics.executable_count).to be == 1
+			expect(statistics.executed_count).to be == 1
 		end
 	end
 end
@@ -105,23 +140,26 @@ def before
 
 	with "multiple coverage objects" do
 		let(:complete_coverage) {Covered::Coverage.new(source, [nil, 1, 1])}
-		let(:partial_coverage) {Covered::Coverage.new(source, [nil, 1, 0])}
 		let(:other_coverage) {Covered::Coverage.new(other_source, [nil, 0])}
-		let(:aggregate) {subject.new([complete_coverage, partial_coverage, other_coverage])}
+		let(:aggregate) {subject.for([complete_coverage, other_coverage])}
 
-		it "merges coverage for the same path" do
+		it "summarizes coverage" do
 			expect(aggregate.count).to be == 2
 			expect(aggregate.executable_count).to be == 3
 			expect(aggregate.executed_count).to be == 2
 		end
 	end
 
-	with "an existing aggregate" do
+	with "an aggregate" do
 		let(:coverage) {Covered::Coverage.new(source, [nil, 1])}
-		let(:aggregate) {subject.new([coverage])}
+		let(:aggregate) {subject.for([coverage])}
 
-		it "is immutable" do
-			expect(aggregate).to be(:frozen?)
+		it "can add coverage" do
+			aggregate << Covered::Coverage.new(other_source, [nil, 0])
+			
+			expect(aggregate.count).to be == 2
+			expect(aggregate.executable_count).to be == 2
+			expect(aggregate.executed_count).to be == 1
 		end
 	end
 end