Use golangci-lint to modernize my Go

1 files changed, 39 insertions, 39 deletions

diff --git a/bin-src/tls-pem2html.go b/bin-src/tls-pem2html.go
index 5664d73..dcf22ba 100644
--- a/bin-src/tls-pem2html.go
+++ b/bin-src/tls-pem2html.go
@@ -5,9 +5,10 @@ package main
 import (
 	"crypto/x509"
 	"encoding/pem"
+	"errors"
 	"fmt"
 	"html/template"
-	"io/ioutil"
+	"io"
 	"os"
 	"sort"
 	"time"
@@ -15,21 +16,7 @@ import (
 	"git.lukeshu.com/dashboard/bin-src/util"
 )
 
-func handleErr(err error, str string, a ...interface{}) {
-	a = append([]interface{}{err}, a...)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, str, a...)
-		os.Exit(1)
-	}
-}
-
-func handleBool(ok bool, str string, a ...interface{}) {
-	if !ok {
-		fmt.Fprintf(os.Stderr, str, a...)
-		os.Exit(1)
-	}
-}
-
+//nolint:gochecknoglobals // would be constant
 var tmpl = template.Must(template.New("pem2html").
 	Funcs(template.FuncMap{
 		"red":           red,
@@ -61,37 +48,37 @@ var tmpl = template.Must(template.New("pem2html").
 
 func getNow() time.Time {
 	stat, err := os.Stdin.Stat()
-	if err == nil {
-		return stat.ModTime()
-	} else {
+	if err != nil {
 		return time.Now()
 	}
+	return stat.ModTime()
 }
 
+//nolint:gochecknoglobals // FIXME
 var now = getNow()
 
 func green(t time.Time) string {
-	max := byte(0xF3)
+	const maxgreen = byte(0xF3)
 	// When did we get the cert?
 	//  - 30 days ago => 0 green
 	//  - just now => max green
 	greenness := util.MapRange(
-		util.TimeRange{now.AddDate(0, 0, -30), now},
-		util.ByteRange{0, max},
+		util.TimeRange{A: now.AddDate(0, 0, -30), B: now},
+		util.ByteRange{A: 0, B: maxgreen},
 		t)
-	return fmt.Sprintf("#%02X%02X%02X", max-greenness, max, max-greenness)
+	return fmt.Sprintf("#%02X%02X%02X", maxgreen-greenness, maxgreen, maxgreen-greenness)
 }
 
 func red(t time.Time) string {
-	max := byte(0xF3)
+	const maxred = byte(0xF3)
 	// When with the cert expire?
-	//  - now => max red
+	//  - now => maxred red
 	//  - 30 days from now => 0 red
 	redness := util.MapRange(
-		util.TimeRange{now, now.AddDate(0, 0, 30)},
-		util.ByteRange{max, 0},
+		util.TimeRange{A: now, B: now.AddDate(0, 0, 30)},
+		util.ByteRange{A: maxred, B: 0},
 		t)
-	return fmt.Sprintf("#%02X%02X%02X", max, max-redness, max-redness)
+	return fmt.Sprintf("#%02X%02X%02X", maxred, maxred-redness, maxred-redness)
 }
 
 type Cert struct {
@@ -105,10 +92,11 @@ func (cert Cert) Url() string {
 }
 
 func (cert Cert) Class() string {
-	if cert.Error == "" {
-		return ""
-	} else {
+	switch {
+	case cert.Error != "":
 		return "invalid"
+	default:
+		return ""
 	}
 }
 
@@ -127,14 +115,21 @@ func (l Certs) Less(i, j int) bool {
 
 // Swap swaps the elements with indexes i and j.
 func (l Certs) Swap(i, j int) {
-	tmp := l[i]
-	l[i] = l[j]
-	l[j] = tmp
+	l[i], l[j] = l[j], l[i]
 }
 
 func main() {
-	data, err := ioutil.ReadAll(os.Stdin)
-	handleErr(err, "Error reading stdin: %v\n")
+	if err := mainWithError(); err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "%s: error: %v", os.Args[0], err)
+		os.Exit(1)
+	}
+}
+
+func mainWithError() error {
+	data, err := io.ReadAll(os.Stdin)
+	if err != nil {
+		return fmt.Errorf("reading stdin: %w", err)
+	}
 
 	var certs Certs
 	for len(data) > 0 {
@@ -145,9 +140,11 @@ func main() {
 		var cert Cert
 
 		cert.Socket, ok = certPem.Headers["X-Socket"]
-		handleBool(ok, "Did not get X-Socket\n")
+		if !ok {
+			return errors.New("did not get X-Socket")
+		}
 
-		cert.Error, ok = certPem.Headers["X-Error"]
+		cert.Error = certPem.Headers["X-Error"]
 
 		cert.X509, err = x509.ParseCertificate(certPem.Bytes)
 		if err != nil {
@@ -158,5 +155,8 @@ func main() {
 	}
 
 	sort.Sort(certs)
-	handleErr(tmpl.Execute(os.Stdout, map[string]interface{}{"certs": certs, "now": now}), "Could not execute template: %v\n")
+	if err := tmpl.Execute(os.Stdout, map[string]any{"certs": certs, "now": now}); err != nil {
+		return fmt.Errorf("executing template: %w", err)
+	}
+	return nil
 }