Add CLI support for coverage thresholds (#54)

Fixes #43

Author: Mathias M

README.md

@@ -28,29 +28,37 @@ List available themes|`-lt`|`1.2.0`
 Render with a specific theme|`-t <theme>`|`1.2.0`
 New `kit` theme |`-t kit`|`1.3.0`
 Put lower coverage functions on top|`-r`|`1.3.1`
+Only show functions whose coverage is smaller than a max threshold|`-cmax`|`1.4.0`
+Only show functions whose coverage is greater than a min threshold|`-cmin`|`1.4.0`
 
 ## Usage
 
 ```
-$ gocov-html -h
-Usage of ./gocov-html:
+Usage of gocov-html:
+  -cmax uint
+        only show functions whose coverage is less than cmax (default 100)
+  -cmin uint
+        only show functions whose coverage is more than cmin
   -d    output CSS of default theme
   -lt
         list available themes
+  -r    put lower coverage functions on top
   -s string
         path to custom CSS file
   -t string
         theme to use for rendering (default "golang")
   -v    show program version
 ```
 
-`gocov-html` can read a JSON file or read from standard input:
+## Examples
+
+Generate code coverage for the `strings` package then generate an HTML report:
 ```
 $ gocov test strings | gocov-html > strings.html
 ok      strings 0.700s  coverage: 98.1% of statements
 ```
 
-Several packages can be tested at once and added to a single report. Let's test the `fmt`, `math` and `io` packages:
+Merge several coverage stats for different packages into a single report:
 ```
 $ gocov test fmt math io | gocov-html > report.html
 ok      fmt     0.045s  coverage: 95.2% of statements
@@ -60,29 +68,23 @@ ok      io      0.024s  coverage: 88.2% of statements
 
 In this case, the generated report will have an *overview* section with stats per package along with the global coverage percentage. This section may be rendered depending on the theme used. The `golang` (default) theme displays it.
 
-The generated HTML content comes along with a default embedded CSS. However a custom stylesheet can be used with the `-s` flag:
+List all available themes:
+```
+$ gocov-html -lt
+golang     -- original golang theme (default)
+kit        -- AdminKit theme
+```
+
+Generate a report using a specific theme with `-t`:
 ```
-$ gocov test net/http | gocov-html -s mystyle.css > http.html
+$ gocov test io | gocov-html -t kit > io.html
 ```
 
-As of version 1.2,
-- A `-d` flag is available to write the defaut stylesheet to the standard output. This is provided for convenience and easy editing:
-  ```
-  $ gocov-html -d > newstyle.css
-  ... edit newstyle.css ...
-  $ gocov test strings | gocov-html -s newstyle.css > http.html
-  ```
-- The content of the stylesheet given to `-s` is embedded into the final HTML document
-- Theming capabilities are available (to go further than just using a CSS file) through the use of Go templates.
-  - Use the `-lt` flag to list available themes:
-    ```
-    $ gocov-html -lt
-    golang     -- original golang theme (default)
-    ```
-  - Generate a report using a specific theme with `-t`:
-    ```
-    $ gocov test io | gocov-html -t golang > io.html
-    ```
+Only show functions whose code coverage is lower than 90% for the `strings` package:
+```
+$ gocov test strings|./gocov-html -cmax 90 > strings.html
+```
+In this example, only 5 matches are added to the report.
 
 ## Donate
 

cmd/gocov-html/main.go

@@ -43,6 +43,8 @@ func main() {
 	listThemes := flag.Bool("lt", false, "list available themes")
 	theme := flag.String("t", "golang", "theme to use for rendering")
 	reverseOrder := flag.Bool("r", false, "put lower coverage functions on top")
+	maxCoverage := flag.Uint64("cmax", 100, "only show functions whose coverage is greater than cmax")
+	minCoverage := flag.Uint64("cmin", 0, "only show functions whose coverage is smaller than cmin")
 
 	flag.Parse()
 
@@ -63,6 +65,13 @@ func main() {
 		return
 	}
 
+	if *minCoverage > *maxCoverage {
+		log.Fatal("error: empty report if cmin > cmax, please use a smaller cmin value.")
+	}
+	if *maxCoverage > 100 {
+		*maxCoverage = 100
+	}
+
 	err := themes.Use(*theme)
 	if err != nil {
 		log.Fatalf("theme selection: %v", err)
@@ -85,7 +94,13 @@ func main() {
 		log.Fatalf("Usage: %s data.json\n", os.Args[0])
 	}
 
-	if err := cov.HTMLReportCoverage(r, *reverseOrder, *css); err != nil {
+	opts := cov.ReportOptions{
+		LowCoverageOnTop: *reverseOrder,
+		Stylesheet:       *css,
+		CoverageMin:      uint8(*minCoverage),
+		CoverageMax:      uint8(*maxCoverage),
+	}
+	if err := cov.HTMLReportCoverage(r, opts); err != nil {
 		log.Fatal(err)
 	}
 }

pkg/cov/report.go

@@ -37,6 +37,24 @@ import (
 	"github.com/rotisserie/eris"
 )
 
+// ReportOptions holds various options used when generating the final
+// HTML report.
+type ReportOptions struct {
+	// LowCoverageOnTop puts low coverage functions first.
+	LowCoverageOnTop bool
+	// Stylesheet is the path to a custom CSS file.
+	Stylesheet string
+	// CoverageMin filters out all functions whose code coverage is smaller than it is.
+	CoverageMin uint8
+	// CoverageMax filters out all functions whose code coverage is greater than it is.
+	CoverageMax uint8
+}
+
+type report struct {
+	ReportOptions
+	packages []*gocov.Package
+}
+
 func unmarshalJSON(data []byte) (packages []*gocov.Package, err error) {
 	result := &struct{ Packages []*gocov.Package }{}
 	err = json.Unmarshal(data, result)
@@ -46,11 +64,6 @@ func unmarshalJSON(data []byte) (packages []*gocov.Package, err error) {
 	return
 }
 
-type report struct {
-	packages   []*gocov.Package
-	stylesheet string // absolute path to CSS
-}
-
 type reverse struct {
 	sort.Interface
 }
@@ -84,32 +97,36 @@ func (r *report) clear() {
 	r.packages = nil
 }
 
-func buildReportPackage(pkg *gocov.Package, lowCoverageOnTop bool) types.ReportPackage {
+func buildReportPackage(pkg *gocov.Package, r *report) types.ReportPackage {
 	rv := types.ReportPackage{
 		Pkg:       pkg,
-		Functions: make(types.ReportFunctionList, len(pkg.Functions)),
+		Functions: make(types.ReportFunctionList, 0),
 	}
-	for i, fn := range pkg.Functions {
+	for _, fn := range pkg.Functions {
 		reached := 0
 		for _, stmt := range fn.Statements {
 			if stmt.Reached > 0 {
 				reached++
 			}
 		}
-		rv.Functions[i] = types.ReportFunction{Function: fn, StatementsReached: reached}
+		rf := types.ReportFunction{Function: fn, StatementsReached: reached}
+		covp := rf.CoveragePercent()
+		if covp >= float64(r.CoverageMin) && covp <= float64(r.CoverageMax) {
+			rv.Functions = append(rv.Functions, rf)
+		}
 		rv.TotalStatements += len(fn.Statements)
 		rv.ReachedStatements += reached
 	}
-	if lowCoverageOnTop {
+	if r.LowCoverageOnTop {
 		sort.Sort(rv.Functions)
 	} else {
 		sort.Sort(reverse{rv.Functions})
 	}
 	return rv
 }
 
-// PrintReport prints a coverage report to the given writer.
-func printReport(w io.Writer, lowCoverageOnTop bool, r *report) error {
+// printReport prints a coverage report to the given writer.
+func printReport(w io.Writer, r *report) error {
 	theme := themes.Current()
 	data := theme.Data()
 
@@ -125,9 +142,9 @@ func printReport(w io.Writer, lowCoverageOnTop bool, r *report) error {
 		return eris.Wrap(err, "decode script")
 	}
 
-	if len(r.stylesheet) > 0 {
+	if len(r.Stylesheet) > 0 {
 		// Inline CSS.
-		f, err := os.Open(r.stylesheet)
+		f, err := os.Open(r.Stylesheet)
 		if err != nil {
 			return eris.Wrap(err, "print report")
 		}
@@ -140,14 +157,17 @@ func printReport(w io.Writer, lowCoverageOnTop bool, r *report) error {
 	reportPackages := make(types.ReportPackageList, len(r.packages))
 	pkgNames := make([]string, len(r.packages))
 	for i, pkg := range r.packages {
-		reportPackages[i] = buildReportPackage(pkg, lowCoverageOnTop)
+		reportPackages[i] = buildReportPackage(pkg, r)
 		pkgNames[i] = pkg.Name
 	}
 
 	data.Script = string(sc)
 	data.Style = css
 	data.Packages = reportPackages
-	data.Command = fmt.Sprintf("gocov test %s | gocov-html -t %s", strings.Join(pkgNames, " "), theme.Name())
+	data.Command = fmt.Sprintf("gocov test %s | gocov-html %s",
+		strings.Join(pkgNames, " "),
+		strings.Join(os.Args[1:], " "),
+	)
 
 	if len(reportPackages) > 1 {
 		rv := types.ReportPackage{
@@ -174,19 +194,20 @@ func exists(path string) (bool, error) {
 // parsing JSON data generated by axw/gocov. The css parameter
 // is an absolute path to a custom stylesheet. Use an empty
 // string to use the default stylesheet available.
-func HTMLReportCoverage(r io.Reader, lowCoverageOnTop bool, css string) error {
+func HTMLReportCoverage(r io.Reader, opts ReportOptions) error {
 	t0 := time.Now()
 	report := newReport()
+	report.ReportOptions = opts
 
 	// Custom stylesheet?
 	stylesheet := ""
-	if css != "" {
-		if _, err := exists(css); err != nil {
+	if opts.Stylesheet != "" {
+		if _, err := exists(opts.Stylesheet); err != nil {
 			return eris.Wrap(err, "stylesheet")
 		}
-		stylesheet = css
+		stylesheet = opts.Stylesheet
 	}
-	report.stylesheet = stylesheet
+	report.Stylesheet = stylesheet
 
 	data, err := ioutil.ReadAll(r)
 	if err != nil {
@@ -202,7 +223,7 @@ func HTMLReportCoverage(r io.Reader, lowCoverageOnTop bool, css string) error {
 		report.addPackage(pkg)
 	}
 	fmt.Println()
-	err = printReport(os.Stdout, lowCoverageOnTop, report)
+	err = printReport(os.Stdout, report)
 	fmt.Fprintf(os.Stderr, "Took %v\n", time.Since(t0))
 	return eris.Wrap(err, "HTML report")
 }

pkg/themes/kit_gen.go

@@ -215,6 +215,9 @@ <h5 class="card-title mb-0" id="fn_{{$f.Name}}"><code class="codex">func {{$f.Na
 						</div>
 						<div class="col-6 text-end">
 							<ul class="list-inline">
+								<li class="list-inline-item">
+									<a class="text-muted" href="{{.ProjectURL}}#donate" target="_blank">Donate!</a>
+								</li>
 								<li class="list-inline-item">
 									<a class="text-muted" href="{{.ProjectURL}}" target="_blank">GitHub</a>
 								</li>