covered 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 025c9e0620ca9bbb2115fc1dcaca9f36c4d827fb047ee303645bf80d4fc3db0e
-  data.tar.gz: 4fd5fd8b45eaf3a90e43b9813c2e86d24a9e3081233e5f1bd24a6bda8b005ce2
+  metadata.gz: 201e73d2bc612e802b0e41f05944bf7ba7b293d9d4e2672140eea2bdbee1f639
+  data.tar.gz: d9f3b4eaf2d53d6fe394753c3a5c0945854239cf0f19c8148464aa5b76e52478
 SHA512:
-  metadata.gz: 8c3f947a44f456b9278ff554487a0262d29e02d8aa0719d6ac57810b4d780c82cf3d0bffd70ddc47daffeccf64cec3a736c244449791501b93a33c14b9439305
-  data.tar.gz: 1b7a1c9456e8529d3b248dd1d50f0bf6a9448522951acbcc021a0fa55de17dc14ed3aa214411c9a1a9144f27c30954a131f0b3b92d82fa34e76db4af2a474e08
+  metadata.gz: d9760ff45293a83ed132c467919871926a01f477e84d2627ab656bb752aeb57ec707e992941f66cc37a119378da51c1cca2b671d5783b2a8e77d9b335e0dea12
+  data.tar.gz: e1774282c354fad33bbe7e5317eedb18ff3d5f7d8ce58eafe3d1d20ac69d6002127adcf72414b953376e4fc32de7301d6a214c79d25bf98d31b14d236780098a

data/Gemfile

@@ -1,6 +1,8 @@
 source "https://rubygems.org"
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
-
 # Specify your gem's dependencies in covered.gemspec
 gemspec
+
+group :development do
+	gem "pry"
+end

data/README.md

@@ -1,22 +1,22 @@
-# Covered
+# Covered [![Build Status](https://travis-ci.com/ioquatix/covered.svg)](hhttps://travis-ci.com/ioquatix/covered)
 
 Covered uses modern Ruby features to generate comprehensive coverage, including support for templates which are compiled into Ruby.
 
-[![Build Status](https://travis-ci.com/ioquatix/covered.svg)](hhttps://travis-ci.com/ioquatix/covered)
+![Screenshot](media/example.png)
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'covered'
+	gem 'covered'
 
 And then execute:
 
-    $ bundle
+	$ bundle
 
 Or install it yourself as:
 
-    $ gem install covered
+	$ gem install covered
 
 ## Usage
 
@@ -38,7 +38,7 @@ require 'covered/rspec'
 
 Released under the MIT license.
 
-Copyright, 2015, by [Samuel G. D. Williams](http://www.codeotaku.com/samuel-williams).
+Copyright, 2018, by [Samuel G. D. Williams](http://www.codeotaku.com/samuel-williams).
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/lib/covered/capture.rb

@@ -18,39 +18,32 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'rainbow'
+require_relative 'wrapper'
 
 module Covered
-	class Capture
+	class Capture < Wrapper
 		def initialize(output)
-			@paths = {}
+			super(output)
 			
-			@line_trace = TracePoint.new(:line) do |trace_point|
+			@trace = TracePoint.new(:line, :call) do |trace_point|
 				if path = trace_point.path
-					# if path =~ /\.xnode$/
-					# 	binding.pry
-					# end
-					# 
-					output.mark(path, trace_point.lineno)
+					@output.mark(path, trace_point.lineno)
 				end
 			end
-			# 
-			# @call_trace = TracePoint.new(:c_call) do |trace_point|
-			# 	if trace_point.method_id == :eval
-			# 	end
-			# end
 		end
 		
 		attr :paths
 		
 		def enable
-			# @call_trace.enable
-			@line_trace.enable
+			super
+			
+			@trace.enable
 		end
 		
 		def disable
-			@line_trace.disable
-			# @call_trace.disable
+			@trace.disable
+			
+			super
 		end
 	end
 end

data/lib/covered/eval.rb

@@ -18,61 +18,61 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'thread'
+
+module Covered
+	module Eval
+		@mutex = Mutex.new
+		@handler = nil
+		
+		def self.enable(handler)
+			@mutex.synchronize do
+				@handler = handler
+			end
+		end
+		
+		def self.disable(handler)
+			@mutex.synchronize do
+				@handler = nil
+			end
+		end
+		
+		def self.intercept_eval(*args)
+			@mutex.synchronize do
+				@handler.intercept_eval(*args) if @handler
+			end
+		end
+	end
+end
+
 module Kernel
 	class << self
-		alias_method :original_eval, :eval
+		alias_method :__eval__, :eval
 		
 		def eval(*args)
-			if source = $source
-				source.map(*args)
-			end
+			Covered::Eval.intercept_eval(*args)
 			
-			original_eval(*args)
+			__eval__(*args)
 		end
 	end
 	
 	private
 	
-	alias_method :original_eval, :eval
+	alias_method :__eval__, :eval
 	
 	def eval(*args)
-		if source = $source
-			source.map(*args)
-		end
+		Covered::Eval.intercept_eval(*args)
 		
-		original_eval(*args)
+		__eval__(*args)
 	end
 end
 
 class Binding
-	alias_method :original_eval, :eval
+	alias_method :__eval__, :eval
 	
 	def eval(*args)
-		if source = $source
-			source.map(*args)
-		end
+		Covered::Eval.intercept_eval(*args)
 		
-		original_eval(*args)
+		__eval__(*args)
 	end
 end
-
-# class BasicObject
-# 	alias_method :original_instance_eval, :instance_eval
-# 
-# 	def instance_eval(*args, &block)
-# 		puts args.inspect
-# 		original_instance_eval(*args, &block)
-# 	end
-# end
-# 
-# class Module
-# 	alias_method :original_module_eval, :module_eval
-# 
-# 	def module_eval(*args, &block)
-# 		puts args.inspect
-# 		original_module_eval(*args, &block)
-# 	end
-# 
-# 	remove_method :class_eval
-# 	alias_method :class_eval, :module_eval
-# end

data/lib/covered/files.rb

@@ -18,15 +18,22 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'set'
+
 module Covered
-	class Files
-		def initialize
+	class Files < Wrapper
+		def initialize(output = nil)
+			super(output)
+			
 			@paths = {}
-			@map = {}
 		end
 		
 		attr :paths
 		
+		def empty?
+			@paths.empty?
+		end
+		
 		def mark(path, lineno)
 			file = @paths[path] ||= []
 			
@@ -42,42 +49,97 @@ module Covered
 		end
 	end
 	
-	class Ignore
-		def initialize(pattern, output)
+	class Include < Wrapper
+		def initialize(output, pattern)
+			super(output)
+			
 			@pattern = pattern
-			@output = output
 		end
 		
-		def mark(path, lineno)
-			@output.mark(path, lineno) unless @pattern.match? path
+		attr :pattern
+		
+		def glob
+			paths = Set.new
+			
+			Dir.glob(@pattern) do |path|
+				unless File.directory?(path)
+					paths << File.realpath(path)
+				end
+			end
+			
+			return paths
+		end
+		
+		def each(&block)
+			paths = glob
+			
+			super do |path, lines|
+				paths.delete(path)
+				
+				yield path, lines
+			end
+			
+			paths.each do |path|
+				yield path, []
+			end
 		end
 	end
 	
-	class Group
-		def initialize(patterns, output)
-			@patterns = patterns
-			@output = output
+	class Filter < Wrapper
+		def accept?(path)
+			true
 		end
 		
 		def mark(path, lineno)
-			@patterns.each do |pattern, output|
-				return output.mark(path, lineno) if pattern.match? path
+			super if accept?(path)
+		end
+		
+		def each(&block)
+			super do |path, counts|
+				yield path, counts if accept?(path)
 			end
+		end
+	end
+	
+	class Skip < Filter
+		def initialize(output, pattern)
+			super(output)
 			
-			@output.mark(path, lineno) if @output
+			@pattern = pattern
+		end
+		
+		attr :pattern
+		
+		def accept? path
+			!(@pattern === path)
 		end
 	end
 	
-	class Relative
-		def initialize(root, output)
-			@root = root
-			@output = output
+	class Only < Filter
+		def initialize(output, pattern)
+			super(output)
+			
+			@pattern = pattern
 		end
 		
-		def mark(path, lineno)
-			if path.start_with? @root
-				@output.mark(path, lineno)
-			end
+		attr :pattern
+		
+		def accept?(path)
+			@pattern === path
+		end
+	end
+	
+	class Root < Filter
+		def initialize(output, path)
+			super(output)
+			
+			@path = path
+		end
+		
+		attr :path
+		
+		def accept?(path)
+			path.start_with?(@path)
 		end
 	end
 end

data/lib/covered/policy.rb

@@ -0,0 +1,91 @@
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require_relative "report"
+require_relative "files"
+require_relative "source"
+require_relative "capture"
+
+module Covered
+	def self.policy(&block)
+		policy = Policy.new
+		
+		policy.instance_eval(&block)
+		
+		policy.freeze
+		
+		return policy
+	end
+	
+	class Policy < Wrapper
+		def initialize
+			super(Files.new)
+		end
+		
+		def freeze
+			return if frozen?
+			
+			capture
+			report
+			
+			super
+		end
+		
+		def source(*args)
+			@output = Source.new(@output, *args)
+		end
+		
+		def include(*args)
+			@output = Include.new(@output, *args)
+		end
+		
+		def skip(*args)
+			@output = Skip.new(@output, *args)
+		end
+		
+		def only(*args)
+			@output = Only.new(@output, *args)
+		end
+		
+		def root(*args)
+			@output = Root.new(@output, *args)
+		end
+		
+		def capture
+			@capture ||= Capture.new(@output)
+		end
+		
+		def enable
+			capture.enable
+		end
+		
+		def disable
+			capture.disable
+		end
+		
+		def report
+			@report ||= Report.new(@output)
+		end
+		
+		def print_summary(*args)
+			report.print_partial_summary(*args)
+		end
+	end
+end

data/lib/covered/report.rb

@@ -18,32 +18,22 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'rainbow'
+require_relative 'statistics'
+require_relative 'wrapper'
 
-require_relative 'ast'
+require 'rainbow'
 
 module Covered
-	class Report
-		def initialize(source)
-			@source = source
-		end
-		
-		def expand(node, lines)
-			# puts "#{node.first_lineno}: #{node.inspect}"
-			
-			lines[node.first_lineno] ||= 0 if node.executable?
-			
-			node.children.each do |child|
-				next if child.nil?
-				
-				expand(child, lines)
-			end
-		end
-		
+	class Report < Wrapper
 		# A coverage array gives, for each line, the number of line execution by the interpreter. A nil value means coverage is disabled for this line (lines like else and end).
 		def print_summary(output = $stdout)
-			@source.each do |path, ast, counts|
-				expand(ast, counts)
+			statistics = Statistics.new
+			
+			@output.each do |path, counts|
+				coverage = Coverage.new(path, counts)
+				statistics << coverage
+				
+				next if coverage.complete?
 				
 				line_offset = 1
 				output.puts Rainbow(path).bold.underline
@@ -52,8 +42,8 @@ module Covered
 					file.each_line do |line|
 						count = counts[line_offset]
 						
-						output.write("#{line_offset}".rjust(4))
-						output.write(" #{count}|".rjust(4))
+						output.write("#{line_offset}|".rjust(8))
+						output.write("#{count}:".rjust(8))
 						
 						if count == nil
 							output.write Rainbow(line).faint
@@ -72,11 +62,62 @@ module Covered
 					end
 				end
 				
-				covered = counts.compact
-				hits = covered.reject(&:zero?)
-				percentage = Rational(hits.count, covered.count) * 100
-				output.puts "** #{hits.count}/#{covered.count} lines executed; #{percentage.to_f.round(2)}% covered."
+				coverage.print_summary(output)
 			end
+			
+			statistics.print_summary(output)
+			
+			return statistics
+		end
+		
+		def print_partial_summary(output = $stdout, before: 4, after: 4)
+			statistics = Statistics.new
+			
+			@output.each do |path, counts|
+				coverage = Coverage.new(path, counts)
+				statistics << coverage
+				
+				next if coverage.complete?
+				
+				line_offset = 1
+				output.puts Rainbow(path).bold.underline
+				
+				printing = false
+				
+				File.open(path, "r") do |file|
+					file.each_line do |line|
+						range = Range.new([line_offset - before, 0].max, line_offset+after)
+						
+						if counts[range]&.include?(0)
+							count = counts[line_offset]
+							
+							output.write("#{line_offset}|".rjust(8))
+							output.write("#{count}:".rjust(8))
+							
+							if count == nil
+								output.write Rainbow(line).faint
+							elsif count == 0
+								output.write Rainbow(line).red
+							else
+								output.write Rainbow(line).green
+							end
+							
+							# If there was no newline at end of file, we add one:
+							unless line.end_with? $/
+								output.puts
+							end
+						end
+						
+						line_offset += 1
+					end
+				end
+				
+				coverage.print_summary(output)
+			end
+			
+			statistics.print_summary(output)
+			
+			return statistics
 		end
 	end
 end

data/lib/covered/rspec.rb

@@ -18,20 +18,26 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'pry'
 require_relative '../covered'
 
-files = Covered::Files.new
-root = Dir.pwd
-output = Covered::Relative.new(root, files)
-$source = output = Covered::Source.new(output)
-output = Covered::Ignore.new(/spec/, output)
+$covered = Covered.policy do
+	root Dir.pwd
+	
+	include "lib/**/*.rb"
+	
+	source
+end
 
-report = Covered::Report.new(files)
-capture = Covered::Capture.new(output)
-
-capture.enable
-# 
-# at_exit do
-# 	capture.disable
-# 	report.print_summary
-# end
+RSpec.configure do |config|
+	config.before(:suite) do
+		$covered.enable
+	end
+	
+	config.after(:suite) do |context|
+		$covered.disable
+		
+		statistics = $covered.print_summary
+		expect(statistics).to be_complete
+	end
+end

data/lib/covered/source.rb

@@ -18,19 +18,48 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require_relative 'eval'
+require_relative 'wrapper'
+
+require 'thread'
+
 module Covered
-	class Source
-		def initialize(files)
-			@files = files
-			@paths = {}
+	# The source map, loads the source file, parses the AST to generate which lines contain executable code.
+	class Source < Wrapper
+		EXECUTABLE = /NODE_(.?CALL|.VAR|.ASGN|DEFN)/.freeze
+		
+		# Deviate from the standard policy above, because all the files are already loaded, so we skip NODE_FCALL.
+		DOGFOOD = /NODE_([V]?CALL|.VAR|.ASGN|DEFN)/.freeze
+		
+		# Ruby trace points don't trigger for argument execution.
+		# Constants are loaded when the file loads, so they are less interesting.
+		IGNORE = /NODE_(ARGS|CDECL)/.freeze
+		
+		def initialize(output, executable: EXECUTABLE, ignore: IGNORE)
+			super(output)
 			
+			@paths = {}
 			@mutex = Mutex.new
+			
+			@executable = executable
+			@ignore = ignore
+		end
+		
+		def enable
+			super
+			
+			Eval::enable(self)
+		end
+		
+		def disable
+			Eval::disable(self)
+			
+			super
 		end
 		
-		# [String -> Source]
 		attr :paths
 		
-		def map(string, binding = nil, filename = nil, lineno = 1)
+		def intercept_eval(string, binding = nil, filename = nil, lineno = 1)
 			return unless filename
 			
 			# TODO replace with Concurrent::Map
@@ -39,17 +68,48 @@ module Covered
 			end
 		end
 		
-		def mark(path, lineno)
-			@files.mark(path, lineno)
+		def executable?(node)
+			node.type =~ @executable
+		end
+		
+		def ignore?(node)
+			# NODE_ARGS Ruby doesn't report execution of arguments in :line tracepoint.
+			node.type =~ @ignore
+		end
+		
+		def expand(node, lines)
+			# puts "#{node.first_lineno}: #{node.inspect}"
+			
+			lines[node.first_lineno] ||= 0 if executable?(node)
+			
+			node.children.each do |child|
+				next if child.nil? or ignore?(child)
+				
+				expand(child, lines)
+			end
+		end
+		
+		def parse(path)
+			# puts "Parse #{path}"
+			
+			if source = @paths[path]
+				RubyVM::AST.parse(source)
+			elsif File.exist?(path)
+				RubyVM::AST.parse_file(path)
+			else
+				warn "Couldn't parse #{path}, file doesn't exist?"
+			end
 		end
 		
 		def each(&block)
-			@files.each do |path, lines|
-				if source = @paths[path]
-					yield path, RubyVM::AST.parse(source), lines
-				else
-					yield path, RubyVM::AST.parse_file(path), lines
+			@output.each do |path, lines|
+				lines = lines.dup
+				
+				if top = parse(path)
+					expand(top, lines)
 				end
+				
+				yield path, lines
 			end
 		end
 	end

data/lib/covered/statistics.rb

@@ -0,0 +1,100 @@
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+module Covered
+	class Statistics
+		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 << coverage
+			@count += 1
+			@executable_count += coverage.executable_count
+			@executed_count += coverage.executed_count
+		end
+		
+		def percentage
+			return nil if executable_count.zero?
+			
+			Rational(executed_count, executable_count) * 100
+		end
+		
+		def complete?
+			executed_count == executable_count
+		end
+		
+		def print_summary(output)
+			output.puts "* #{count} files checked; #{executed_count}/#{executable_count} lines executed; #{percentage.to_f.round(2)}% covered."
+		end
+	end
+	
+	class Coverage
+		def initialize(path, lines)
+			@path = path
+			@lines = lines
+			
+			@executable_lines = nil
+			@executed_lines = nil
+		end
+		
+		attr :lines
+		
+		def executable_lines
+			@executable_lines ||= @lines.compact
+		end
+		
+		def executable_count
+			executable_lines.count
+		end
+		
+		def executed_lines
+			@executed_lines ||= executable_lines.reject(&:zero?)
+		end
+		
+		def executed_count
+			executed_lines.count
+		end
+		
+		def complete?
+			executed_count == executable_count
+		end
+		
+		def percentage
+			return nil if executable_count.zero?
+			
+			Rational(executed_count, executable_count) * 100
+		end
+		
+		def print_summary(output)
+			output.puts "** #{executed_count}/#{executable_count} lines executed; #{percentage.to_f.round(2)}% covered."
+		end
+	end
+end

data/lib/covered/version.rb

@@ -19,5 +19,5 @@
 # THE SOFTWARE.
 
 module Covered
-	VERSION = "0.1.0"
+	VERSION = "0.3.0"
 end

data/lib/covered/{ast.rb → wrapper.rb}

@@ -18,8 +18,29 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-class RubyVM::AST::Node
-	def executable?
-		self.type =~ /NODE_(CALL|IVAR|LVAR|IASGN)/
+module Covered
+	class Wrapper
+		def initialize(output = nil)
+			@output = output
+		end
+		
+		attr :output
+		
+		def mark(path, lineno)
+			@output.mark(path, lineno) if @output
+		end
+		
+		def enable
+			@output.enable if @output
+		end
+		
+		def disable
+			@output.disable if @output
+		end
+		
+		# @yield [path, counts] the path to the file, and the execution counts.
+		def each(&block)
+			@output.each(&block)
+		end
 	end
 end

data/lib/covered.rb

@@ -20,7 +20,4 @@
 
 require_relative "covered/version"
 
-require_relative "covered/report"
-require_relative "covered/files"
-require_relative "covered/source"
-require_relative "covered/capture"
+require_relative "covered/policy"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: covered
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-01 00:00:00.000000000 Z
+date: 2018-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rainbow
@@ -95,14 +95,17 @@ files:
 - Rakefile
 - covered.gemspec
 - lib/covered.rb
-- lib/covered/ast.rb
 - lib/covered/capture.rb
 - lib/covered/eval.rb
 - lib/covered/files.rb
+- lib/covered/policy.rb
 - lib/covered/report.rb
 - lib/covered/rspec.rb
 - lib/covered/source.rb
+- lib/covered/statistics.rb
 - lib/covered/version.rb
+- lib/covered/wrapper.rb
+- media/example.png
 homepage: https://github.com/ioquatix/covered
 licenses: []
 metadata: {}