covered 0.22.1 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c83b08be821b20f583a8e9f7c0c5eff4ded0852016e73e93d3a29f63ed33d79b
-  data.tar.gz: 8a8cf40418633108d9b5bbb491eaf0c06dc7be5f53a11f2bbc3fac4abfca5cd3
+  metadata.gz: 6101920cc470784c2969e8d78252c81678104f6cd882038a306e633f3ec34267
+  data.tar.gz: 213bc88224aba333120b869360a663f02355ace3f1dcb4106c5fcdbebd61cd7e
 SHA512:
-  metadata.gz: 25f75fb59e078f2d89ca296a583a70d3b93817a4bb3e7863dbecc40a0bc13c21d0a0a66a536960c967483f27a036e25063960d40d52c20dde94fe320b34cb634
-  data.tar.gz: 7e594df30c68df8df4cf71f0b8063f69dc0e3885d962cc176bbf0a2bf1c2408d6ab6fe2df31f524bcfc5d6162954a7e6f598084d76c851266fad317e0fbb65f0
+  metadata.gz: aabfd2999173af2de001ce8a4718483c9801497bb064b27c6892d8c6cb80dc8b2207db0de41a0eb8e4116deac5a2eaf8f68cc2febe8acbea84c4795b666992c1
+  data.tar.gz: 302d49b96fcad976a40bc86422976e1526d0b410ed72112190787a8c1ea75309015fe0c6c2fa8359b8d3cf60f9b93f63b021dab063b8e3c1a08d24cb9b79fb59

data/bake/covered/policy.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+def initialize(context)
+	super
+	
+	require_relative '../../lib/covered/config'
+end
+
+# Load the current coverage policy.
+def current(paths: nil)
+	policy = Covered::Policy.new
+	
+	# Load the default path if no paths are specified:
+	paths ||= Dir.glob(Covered::Persist::DEFAULT_PATH, base: context.root)
+	
+	# If no paths are specified, raise an error:
+	if paths.empty?
+		raise ArgumentError, "No coverage paths specified!"
+	end
+	
+	# Load all coverage information:
+	paths.each do |path|
+		# It would be nice to have a better algorithm here than just ignoring mtime - perhaps using checksums?
+		Covered::Persist.new(policy.output, path).load!(ignore_mtime: true)
+	end
+	
+	return policy
+end
+
+# Validate the coverage of multiple test runs.
+# @parameter paths [Array(String)] The coverage database paths.
+# @parameter minimum [Float] The minimum required coverage in order to pass.
+# @parameter input [Covered::Policy] The input policy to validate.
+def statistics(paths: nil, minimum: 1.0, input:)
+	policy ||= context.lookup("covered:policy:current").call(paths: paths)
+	
+	# Calculate statistics:
+	statistics = Covered::Statistics.new
+	
+	policy.each do |coverage|
+		statistics << coverage
+	end
+	
+	return statistics
+end

data/bake/covered/validate.rb

@@ -12,22 +12,9 @@ end
 # Validate the coverage of multiple test runs.
 # @parameter paths [Array(String)] The coverage database paths.
 # @parameter minimum [Float] The minimum required coverage in order to pass.
-def validate(paths: nil, minimum: 1.0)
-	policy = Covered::Policy.new
-	
-	# Load the default path if no paths are specified:
-	paths ||= Dir.glob(Covered::Persist::DEFAULT_PATH, base: context.root)
-	
-	# If no paths are specified, raise an error:
-	if paths.empty?
-		raise ArgumentError, "No coverage paths specified!"
-	end
-	
-	# Load all coverage information:
-	paths.each do |path|
-		# It would be nice to have a better algorithm here than just ignoring mtime - perhaps using checksums?
-		Covered::Persist.new(policy.output, path).load!(ignore_mtime: true)
-	end
+# @parameter input [Covered::Policy] The input policy to validate.
+def validate(paths: nil, minimum: 1.0, input:)
+	policy ||= context.lookup("covered:policy:current").call(paths: paths)
 	
 	# Calculate statistics:
 	statistics = Covered::Statistics.new

data/lib/covered/coverage.rb

@@ -3,10 +3,12 @@
 # Released under the MIT License.
 # Copyright, 2018-2023, by Samuel Williams.
 
+require_relative 'source'
+
 module Covered
 	module Ratio
 		def ratio
-			return 0 if executable_count.zero?
+			return 1.0 if executable_count.zero?
 			
 			Rational(executed_count, executable_count)
 		end
@@ -20,78 +22,72 @@ module Covered
 		end
 	end
 	
-	class Source
-		def self.for(path, code, line_offset)
-			self.new(path, code: code, line_offset: line_offset)
-		end
+	class Coverage
+		include Ratio
 		
-		def initialize(path, code: nil, line_offset: 1, modified_time: nil)
-			@path = path
-			@code = code
-			@line_offset = line_offset
-			@modified_time = modified_time
+		def self.for(path, **options)
+			self.new(Source.for(path, **options))
 		end
 		
-		attr_accessor :path
-		attr :code
-		attr :line_offset
-		attr :modified_time
-		
-		def to_s
-			"\#<#{self.class} path=#{path}>"
+		def initialize(source, counts = [], annotations = {})
+			@source = source
+			@counts = counts
+			@annotations = annotations
 		end
 		
-		def read(&block)
-			if block_given?
-				File.open(self.path, "r", &block)
-			else
-				File.read(self.path)
-			end
-		end
+		attr_accessor :source
+		attr :counts
+		attr :annotations
 		
-		# The actual code which is being covered. If a template generates the source, this is the generated code, while the path refers to the template itself.
-		def code!
-			self.code || self.read
+		def total
+			counts.sum{|count| count || 0}
 		end
 		
-		def code?
-			!!self.code
+		# Create an empty coverage with the same source.
+		def empty
+			self.class.new(@source, [nil] * @counts.size)
 		end
 		
-		def serialize(packer)
-			packer.write(self.path)
-			packer.write(self.code)
-			packer.write(self.line_offset)
-			packer.write(self.modified_time)
+		def annotate(line_number, annotation)
+			@annotations[line_number] ||= []
+			@annotations[line_number] << annotation
 		end
 		
-		def self.deserialize(unpacker)
-			path = unpacker.read
-			code = unpacker.read
-			line_offset = unpacker.read
-			modified_time = unpacker.read
-			
-			self.new(path, code: code, line_offset: line_offset, modified_time: modified_time)
+		def mark(line_number, value = 1)
+			# As currently implemented, @counts is base-zero rather than base-one.
+			# Line numbers generally start at line 1, so the first line, line 1, is at index 1. This means that index[0] is usually nil.
+			Array(value).each_with_index do |value, index|
+				offset = line_number + index
+				if @counts[offset]
+					@counts[offset] += value
+				else
+					@counts[offset] = value
+				end
+			end
 		end
-	end
-	
-	class Coverage
-		include Ratio
 		
-		def self.for(path, **options)
-			self.new(Source.new(path, **options))
+		def merge!(other)
+			other.counts.each_with_index do |count, index|
+				if count
+					@counts[index] ||= 0
+					@counts[index] += count
+				end
+			end
+			
+			@annotations.merge!(other.annotations) do |line_number, a, b|
+				Array(a) + Array(b)
+			end
 		end
 		
-		def initialize(source, counts = [], annotations = {}, total = nil)
-			@source = source
-			@counts = counts
-			@annotations = annotations
-			
-			@total = total || counts.sum{|count| count || 0}
+		# Construct a new coverage object for the given line numbers. Only the given line numbers will be considered for the purposes of computing coverage.
+		# @parameter line_numbers [Array(Integer)] The line numbers to include in the new coverage object.
+		def for_lines(line_numbers)
+			counts = [nil] * @counts.size
+			line_numbers.each do |line_number|
+				counts[line_number] = @counts[line_number]
+			end
 			
-			# Memoized metrics:
-			@executable_lines = nil
-			@executed_lines = nil
+			self.class.new(@source, counts, @annotations)
 		end
 		
 		def path
@@ -104,8 +100,8 @@ module Covered
 		
 		def fresh?
 			if @source.modified_time.nil?
-				# We don't know when the file was last modified, so we assume it is fresh:
-				return true
+				# We don't know when the file was last modified, so we assume it is stale:
+				return false
 			end
 			
 			unless File.exist?(@source.path)
@@ -121,13 +117,6 @@ module Covered
 			return false
 		end
 		
-		attr_accessor :source
-		
-		attr :counts
-		attr :total
-		
-		attr :annotations
-		
 		def read(&block)
 			@source.read(&block)
 		end
@@ -146,15 +135,15 @@ module Covered
 		end
 		
 		def zero?
-			@total.zero?
+			total.zero?
 		end
 		
-		def [] lineno
-			@counts[lineno]
+		def [] line_number
+			@counts[line_number]
 		end
 		
 		def executable_lines
-			@executable_lines ||= @counts.compact
+			@counts.compact
 		end
 		
 		def executable_count
@@ -162,7 +151,7 @@ module Covered
 		end
 		
 		def executed_lines
-			@executed_lines ||= executable_lines.reject(&:zero?)
+			executable_lines.reject(&:zero?)
 		end
 		
 		def executed_count
@@ -178,23 +167,30 @@ module Covered
 		end
 		
 		def to_s
-			"\#<#{self.class} path=#{self.path} #{self.summary.percentage.to_f.round(2)}% covered>"
+			"\#<#{self.class} path=#{self.path} #{self.percentage.to_f.round(2)}% covered>"
+		end
+		
+		def as_json
+			{
+				counts: counts,
+				executable_count: executable_count,
+				executed_count: executed_count,
+				percentage: percentage.to_f.round(2),
+			}
 		end
 		
 		def serialize(packer)
 			packer.write(@source)
 			packer.write(@counts)
 			packer.write(@annotations)
-			packer.write(@total)
 		end
 		
 		def self.deserialize(unpacker)
 			source = unpacker.read
 			counts = unpacker.read
 			annotations = unpacker.read
-			total = unpacker.read
 			
-			self.new(source, counts, annotations, total)
+			self.new(source, counts, annotations)
 		end
 	end
 end

data/lib/covered/files.rb

@@ -10,60 +10,6 @@ require 'set'
 
 module Covered
 	class Files < Base
-		class State
-			def self.for(path, **options)
-				self.new(Source.new(path, **options))
-			end
-			
-			def initialize(source)
-				@source = source
-				@counts = []
-				@annotations = {}
-			end
-			
-			def [](lineno)
-				@counts[lineno]
-			end
-			
-			attr :counts
-			attr :annotations
-			
-			def annotate(lineno, annotation)
-				@annotations[lineno] ||= []
-				@annotations[lineno] << annotation
-			end
-			
-			def mark(lineno, value = 1)
-				# As currently implemented, @counts is base-zero rather than base-one.
-				# Line numbers generally start at line 1, so the first line, line 1, is at index 1. This means that index[0] is usually nil.
-				Array(value).each_with_index do |value, index|
-					offset = lineno + index
-					if @counts[offset]
-						@counts[offset] += value
-					else
-						@counts[offset] = value
-					end
-				end
-			end
-			
-			def merge!(coverage)
-				coverage.counts.each_with_index do |count, index|
-					if count
-						@counts[index] ||= 0
-						@counts[index] += count
-					end
-				end
-				
-				@annotations.merge!(coverage.annotations) do |lineno, a, b|
-					Array(a) + Array(b)
-				end
-			end
-			
-			def coverage
-				Coverage.new(@source, @counts, @annotations)
-			end
-		end
-		
 		def initialize(*)
 			super
 			
@@ -73,19 +19,19 @@ module Covered
 		attr_accessor :paths
 		
 		def [](path)
-			@paths[path] ||= State.for(path)
+			@paths[path] ||= Coverage.for(path)
 		end
 		
 		def empty?
 			@paths.empty?
 		end
 		
-		def mark(path, lineno, value)
-			self[path].mark(lineno, value)
+		def mark(path, line_number, value)
+			self[path].mark(line_number, value)
 		end
 		
-		def annotate(path, lineno, value)
-			self[path].annotate(lineno, value)
+		def annotate(path, line_number, value)
+			self[path].annotate(line_number, value)
 		end
 		
 		def add(coverage)
@@ -95,8 +41,8 @@ module Covered
 		def each
 			return to_enum unless block_given?
 			
-			@paths.each_value do |state|
-				yield state.coverage
+			@paths.each_value do |coverage|
+				yield coverage
 			end
 		end
 		

data/lib/covered/minitest.rb

@@ -21,9 +21,7 @@ module Covered
 end
 
 if $covered.record?
-	class << Minitest
-		prepend Covered::Minitest
-	end
+	Minitest.singleton_class.prepend(Covered::Minitest)
 	
 	Minitest.after_run do
 		$covered.finish

data/lib/covered/persist.rb

@@ -26,8 +26,13 @@ module Covered
 					coverage.path = path
 				end
 				
-				add(coverage)
+				if ignore_mtime || coverage.fresh?
+					add(coverage)
+					return true
+				end
 			end
+			
+			return false
 		end
 		
 		def serialize(coverage)

data/lib/covered/source.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2018-2023, by Samuel Williams.
+
+module Covered
+	class Source
+		def self.for(path, **options)
+			if File.exist?(path)
+				options[:code] ||= File.read(path)
+				options[:modified_time] ||= File.mtime(path)
+			end
+			
+			self.new(path, **options)
+		end
+		
+		def initialize(path, code: nil, line_offset: 1, modified_time: nil)
+			@path = path
+			@code = code
+			@line_offset = line_offset
+			@modified_time = modified_time
+		end
+		
+		attr_accessor :path
+		attr :code
+		attr :line_offset
+		attr :modified_time
+		
+		def to_s
+			"\#<#{self.class} path=#{path}>"
+		end
+		
+		def read(&block)
+			if block_given?
+				File.open(self.path, "r", &block)
+			else
+				File.read(self.path)
+			end
+		end
+		
+		# The actual code which is being covered. If a template generates the source, this is the generated code, while the path refers to the template itself.
+		def code!
+			self.code || self.read
+		end
+		
+		def code?
+			!!self.code
+		end
+		
+		def serialize(packer)
+			packer.write(self.path)
+			packer.write(self.code)
+			packer.write(self.line_offset)
+			packer.write(self.modified_time)
+		end
+		
+		def self.deserialize(unpacker)
+			path = unpacker.read
+			code = unpacker.read
+			line_offset = unpacker.read
+			modified_time = unpacker.read
+			
+			self.new(path, code: code, line_offset: line_offset, modified_time: modified_time)
+		end
+	end
+end

data/lib/covered/statistics.rb

@@ -10,39 +10,116 @@ module Covered
 	class CoverageError < StandardError
 	end
 	
-	class Statistics < Wrapper
+	class Statistics
+		include Ratio
+		
+		def self.for(coverage)
+			self.new.tap do |statistics|
+				statistics << coverage
+			end
+		end
+		
+		class Aggregate
+			include Ratio
+			
+			def initialize
+				@count = 0
+				@executable_count = 0
+				@executed_count = 0
+			end
+			
+			# Total number of files added.
+			attr :count
+			
+			# The number of lines which could have been executed.
+			attr :executable_count
+			
+			# The number of lines that were executed.
+			attr :executed_count
+			
+			def as_json
+				{
+					count: count,
+					executable_count: executable_count,
+					executed_count: executed_count,
+					percentage: percentage.to_f.round(2),
+				}
+			end
+			
+			def to_json(options)
+				as_json.to_json(options)
+			end
+			
+			def << coverage
+				@count += 1
+				
+				@executable_count += coverage.executable_count
+				@executed_count += coverage.executed_count
+			end
+		end
+		
 		def initialize
-			@count = 0
-			@executable_count = 0
-			@executed_count = 0
+			@total = Aggregate.new
+			@paths = Hash.new
 		end
 		
-		# Total number of files added.
-		attr :count
+		def count
+			@paths.size
+		end
 		
-		# The number of lines which could have been executed.
-		attr :executable_count
+		def executable_count
+			@total.executable_count
+		end
 		
-		# The number of lines that were executed.
-		attr :executed_count
+		def executed_count
+			@total.executed_count
+		end
 		
 		def << coverage
-			@count += 1
-			
-			@executable_count += coverage.executable_count
-			@executed_count += coverage.executed_count
+			@total << coverage
+			(@paths[coverage.path] ||= coverage.empty).merge!(coverage)
 		end
 		
-		include Ratio
+		attr :total
+		
+		def [](path)
+			@paths[path]
+		end
+		
+		def as_json
+			{
+				total: total.as_json,
+				paths: @paths.map{|path, coverage| [path, coverage.as_json]}.to_h,
+			}
+		end
+		
+		def to_json(options)
+			as_json.to_json(options)
+		end
+		
+		COMPLETE = [
+			"Enter the code dojo: 100% coverage attained, bugs defeated with one swift strike.",
+			"Nirvana reached: 100% code coverage, where bugs meditate and vanish like a passing cloud.",
+			"With 100% coverage, your code has unlocked the path to enlightenment – bugs have no place to hide.",
+			"In the realm of code serenity, 100% coverage is your ticket to coding enlightenment.",
+			"100% coverage, where code and bugs coexist in perfect harmony, like Yin and Yang.",
+			"Achieving the Zen of code coverage, your code is a peaceful garden where bugs find no shelter.",
+			"Congratulations on coding enlightenment! 100% coverage means your code is one with the universe.",
+			"With 100% coverage, your code is a tranquil pond where bugs cause no ripples.",
+			"At the peak of code mastery: 100% coverage, where bugs bow down before the wisdom of your code.",
+			"100% code coverage: Zen achieved! Bugs in harmony, code at peace.",
+		]
 		
 		def print(output)
-			output.puts "* #{count} files checked; #{executed_count}/#{executable_count} lines executed; #{percentage.to_f.round(2)}% covered."
+			output.puts "#{count} files checked; #{@total.executed_count}/#{@total.executable_count} lines executed; #{@total.percentage.to_f.round(2)}% covered."
 			
-			# Could output funny message here, especially for 100% coverage.
+			if self.complete?
+				output.puts "🧘 #{COMPLETE.sample}"
+			end
 		end
 		
 		def validate!(minimum = 1.0)
-			if self.ratio < minimum
+			if total.ratio < minimum
 				raise CoverageError, "Coverage of #{self.percentage.to_f.round(2)}% is less than required minimum of #{(minimum * 100.0).round(2)}%!"
 			end
 		end

data/lib/covered/version.rb

@@ -4,5 +4,5 @@
 # Copyright, 2018-2023, by Samuel Williams.
 
 module Covered
-	VERSION = "0.22.1"
+	VERSION = "0.24.0"
 end

data/readme.md

@@ -1,86 +1,40 @@
 # Covered
 
-[![Development Status](https://github.com/ioquatix/covered/workflows/Test/badge.svg)](https://github.com/ioquatix/covered/actions?workflow=Test)
+![Screenshot](media/example.png)
 
-Covered uses modern Ruby features to generate comprehensive coverage, including support for templates which are compiled into Ruby.
+Covered uses modern Ruby features to generate comprehensive coverage, including support for templates which are compiled
+into Ruby.
 
-  - Incremental coverage - if you run your full test suite, and the run a subset, it will still report the correct coverage - so you can incrementally work on improving coverage.
-  - Integration with RSpec, Minitest, Travis & Coveralls - no need to configure anything - out of the box support for these platforms.
+  - Incremental coverage - if you run your full test suite, and the run a subset, it will still report the correct
+    coverage - so you can incrementally work on improving coverage.
+  - Integration with Sus, Git, RSpec and Minitest- no need to configure anything - out of the box support for these
+    platforms.
   - Supports coverage of views - templates compiled to Ruby code can be tracked for coverage reporting.
 
-![Screenshot](media/example.png)
+[![Development
+Status](https://github.com/ioquatix/covered/workflows/Test/badge.svg)](https://github.com/ioquatix/covered/actions?workflow=Test)
 
 ## Motivation
 
-Existing Ruby coverage tools are unable to handle `eval`ed code. This is because the `coverage` module built into Ruby doesn't expose the necessary hooks to capture it. Using the [parser](https://github.com/whitequark/parser) gem allows us to do our own source code analysis to compute executable lines, thus making it possible to compute coverage for "templates".
-
-It's still tricky to do it correctly, but it is feasible now to compute coverage of web application "views" by using this technique. This gem is an exploration to see what is possible.
-
-## Installation
-
-Add this line to your application's `Gemfile`:
-
-``` ruby
-gem 'covered'
-```
-
-### RSpec Integration
-
-In your `spec/spec_helper.rb` add the following before loading any other code:
-
-``` ruby
-require 'covered/rspec'
-```
-
-Ensure that you have a `.rspec` file with `--require spec_helper`:
-
-    --require spec_helper
-    --format documentation
-    --warnings
-
-### Minitest Integration
+Originally, Ruby coverage tools were unable to handle `eval`ed code. This is because the `coverage` module built into
+Ruby doesn't expose the necessary hooks to capture it. Using the [parser](https://github.com/whitequark/parser) gem and
+trace points allows us to do our own source code analysis to compute executable lines, thus making it possible to
+compute coverage for "templates".
 
-In your `test/test_helper.rb` add the following before loading any other code:
-
-``` ruby
-require 'covered/minitest'
-require 'minitest/autorun'
-```
-
-In your test files, e.g. `test/dummy_test.rb` add the following at the top:
-
-``` ruby
-require_relative 'test_helper'
-```
+After this concept prooved useful, [it was integrated directly into Ruby](https://bugs.ruby-lang.org/issues/19008).
 
 ## Usage
 
-When running `rspec`, you can specify the kind of coverage analysis you would like:
-
-    COVERAGE=Summary rspec
-
-If no `COVERAGE` is specified, coverage tracking will be finishd.
-
-### Template Coverage
-
-Covered supports coverage of templates which are compiled into Ruby code. This is only supported on Ruby 3.2+ due to enhancements in the coverage interface.
-
-### Partial Summary
-
-    COVERAGE=PartialSummary rspec
-
-This report only shows snippets of source code with incomplete coverage.
-
-### Brief Summary
-
-    COVERAGE=BriefSummary rspec
+Please see the [project documentation](https://github.com/ioquatix/covered) for more details.
 
-This report lists several files in order of least coverage.l
+  - [Getting Started](https://github.com/ioquatix/coveredguides/getting-started/index) - This guide explains how to get
+    started with `covered` and integrate it with your test suite.
 
 ## See Also
 
-  - [coveralls-ruby](https://github.com/lemurheavy/coveralls-ruby) – the official Coveralls implementation for Ruby.
-  - [simplecov](https://github.com/colszowka/simplecov) – one of the original coverage implementations for Ruby, uses the built-in `coverage` library.
+  - [simplecov](https://github.com/colszowka/simplecov) – one of the original coverage implementations for Ruby, uses
+    the built-in `coverage` library.
+  - [sus](https://github.com/ioquatix/sus) - a test framework which uses `covered` to generate coverage reports.
 
 ## Contributing
 
@@ -94,8 +48,10 @@ We welcome contributions to this project.
 
 ### Developer Certificate of Origin
 
-This project uses the [Developer Certificate of Origin](https://developercertificate.org/). All contributors to this project must agree to this document to have their contributions accepted.
+This project uses the [Developer Certificate of Origin](https://developercertificate.org/). All contributors to this
+project must agree to this document to have their contributions accepted.
 
 ### Contributor Covenant
 
-This project is governed by [Contributor Covenant](https://www.contributor-covenant.org/). All contributors and participants agree to abide by its terms.
+This project is governed by [Contributor Covenant](https://www.contributor-covenant.org/). All contributors and
+participants agree to abide by its terms.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: covered
 version: !ruby/object:Gem::Version
-  version: 0.22.1
+  version: 0.24.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -42,7 +42,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2023-07-17 00:00:00.000000000 Z
+date: 2023-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: console
@@ -79,6 +79,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bake/covered/debug.rb
+- bake/covered/policy.rb
 - bake/covered/validate.rb
 - lib/covered.rb
 - lib/covered/autostart.rb
@@ -92,6 +93,7 @@ files:
 - lib/covered/persist.rb
 - lib/covered/policy.rb
 - lib/covered/rspec.rb
+- lib/covered/source.rb
 - lib/covered/statistics.rb
 - lib/covered/summary.rb
 - lib/covered/sus.rb