fix: linting issues

Author: BacchusJackson

.golangci.yaml

@@ -1,7 +1 @@
-linters:
-  enable:
-    - tagalign
-    - gofumpt
-    - gosimple
-    - govet
-    - ineffassign
+version: "2"

Taskfile.yml

@@ -51,12 +51,12 @@ tasks:
   lint:
     desc: "Run golangci-lint in view-only mode"
     cmds:
-      - golangci-lint run --fast
+      - golangci-lint run
 
   fix:
     desc: "Fix linting errors and format code"
     cmds:
-      - golangci-lint run --fast --fix
+      - golangci-lint run --fix
 
   release-snapshot:
     desc: "Create a snapshot release"

cmd/cli-config.go

@@ -13,32 +13,32 @@ import (
 var (
 	metadataFlagUsage       = "flag_usage"
 	metadataFieldType       = "field_type"
-	metadataRequired        = "required"
 	metadataActionInputName = "action_input_name"
+	// metadataRequired        = "required"
 )
 
 type metaConfig struct {
-	BundleTag          configkit.MetaField
-	EPSSURL            configkit.MetaField
-	KEVURL             configkit.MetaField
-	EPSSFilename       configkit.MetaField
-	KEVFilename        configkit.MetaField
-	Verbose            configkit.MetaField
-	Silent             configkit.MetaField
-	ConfigFilename     configkit.MetaField
-	Audit              configkit.MetaField
-	BundleTagValue     []string
-	bundleFile         *os.File
-	targetFile         *os.File
-	epssFile           *os.File
-	kevFile            *os.File
-	listSrcReader      io.Reader
-	listSrcName        string
-	listFormat         string
-	listAll            bool
-	configOutputWriter io.Writer
-	configOutputFormat string
-	gatecheckConfig    *gatecheck.Config
+	BundleTag       configkit.MetaField
+	EPSSURL         configkit.MetaField
+	KEVURL          configkit.MetaField
+	EPSSFilename    configkit.MetaField
+	KEVFilename     configkit.MetaField
+	Verbose         configkit.MetaField
+	Silent          configkit.MetaField
+	ConfigFilename  configkit.MetaField
+	Audit           configkit.MetaField
+	BundleTagValue  []string
+	bundleFile      *os.File
+	targetFile      *os.File
+	epssFile        *os.File
+	kevFile         *os.File
+	listSrcReader   io.Reader
+	listSrcName     string
+	listFormat      string
+	gatecheckConfig *gatecheck.Config
+	// listAll            bool
+	// configOutputWriter io.Writer
+	// configOutputFormat string
 }
 
 var RuntimeConfig = metaConfig{

cmd/gatecheck/main.go

@@ -17,9 +17,9 @@ import (
 
 const (
 	exitSystemFail     int = -1
-	exitOk                 = 0
-	exitValidationFail     = 1
-	exitFileAccessFail     = 2
+	exitOk             int = 0
+	exitValidationFail int = 1
+	exitFileAccessFail int = 2
 )
 
 // GatecheckVersion see CHANGELOG.md
@@ -55,7 +55,7 @@ func run() int {
 	command := cmd.NewGatecheckCommand()
 
 	err := command.Execute()
-	if errors.Is(gatecheck.ErrValidationFailure, err) {
+	if errors.Is(err, gatecheck.ErrValidationFailure) {
 		return exitValidationFail
 	}
 	if err != nil {

cmd/list.go

@@ -21,7 +21,7 @@ var listCmd = &cobra.Command{
 	PreRunE: func(cmd *cobra.Command, args []string) error {
 		inputType, _ := cmd.Flags().GetString("input-type")
 		if inputType == "" && len(args) == 0 {
-			return errors.New("Need either input-type for STDIN or filename as argument")
+			return errors.New("need either input-type for STDIN or filename as argument")
 		}
 
 		var err error = nil
@@ -40,7 +40,7 @@ var listCmd = &cobra.Command{
 
 		RuntimeConfig.listFormat = "ascii"
 
-		if markdownFlag, _ := cmd.Flags().GetBool("markdown"); markdownFlag == true {
+		if markdownFlag, _ := cmd.Flags().GetBool("markdown"); markdownFlag {
 			RuntimeConfig.listFormat = "markdown"
 		}
 

cmd/validate.go

@@ -65,8 +65,8 @@ var validateCmd = &cobra.Command{
 		audit := RuntimeConfig.Audit.Value().(bool)
 		if audit && err != nil {
 			slog.Error("validation failure in audit mode")
-			fmt.Fprintln(cmd.ErrOrStderr(), err)
-			return nil
+			_, err = fmt.Fprintln(cmd.ErrOrStderr(), err)
+			return err
 		}
 
 		return err

pkg/archive/bundle.go

@@ -10,14 +10,15 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/olekukonko/tablewriter"
 	"io"
 	"log/slog"
 	"os"
 	"sort"
 	"strings"
 	"time"
 
+	"github.com/olekukonko/tablewriter"
+
 	"github.com/dustin/go-humanize"
 	"github.com/gatecheckdev/gatecheck/pkg/format"
 )
@@ -74,7 +75,7 @@ func (b *Bundle) Manifest() Manifest {
 func (b *Bundle) WriteFileTo(w io.Writer, fileLabel string) (int64, error) {
 	fileBytes, ok := b.content[fileLabel]
 	if !ok {
-		return 0, fmt.Errorf("Gatecheck Bundle: Label '%s' not found in bundle", fileLabel)
+		return 0, fmt.Errorf("gatecheck bundle: Label '%s' not found in bundle", fileLabel)
 	}
 	return bytes.NewReader(fileBytes).WriteTo(w)
 }
@@ -181,13 +182,18 @@ func TarGzipBundle(dst io.Writer, bundle *Bundle) (int64, error) {
 		_ = tarWriter.WriteHeader(&tar.Header{Name: label, Size: int64(len(data)), Mode: int64(os.FileMode(0o666))})
 		_, _ = bytes.NewReader(data).WriteTo(tarWriter)
 	}
-	tarWriter.Close()
+	if err := tarWriter.Close(); err != nil {
+		return 0, err
+	}
 
 	gzipWriter := gzip.NewWriter(dst)
-	n, _ := tarballBuffer.WriteTo(gzipWriter)
-	gzipWriter.Close()
+	n, err := tarballBuffer.WriteTo(gzipWriter)
+	if err != nil {
+		return n, err
+	}
+	err = gzipWriter.Close()
 
-	return n, nil
+	return n, err
 }
 
 func UntarGzipBundle(src io.Reader, bundle *Bundle) error {
@@ -209,15 +215,15 @@ func UntarGzipBundle(src io.Reader, bundle *Bundle) error {
 		}
 
 		if header.Typeflag != tar.TypeReg {
-			return errors.New("Gatecheck Bundle only supports regular files in a flat directory structure")
+			return errors.New("gatecheck bundle only supports regular files in a flat directory structure")
 		}
 		fileBytes, _ := io.ReadAll(tarReader)
 		bundle.content[header.Name] = fileBytes
 	}
 	manifest := new(Manifest)
 	manifestBytes, ok := bundle.content[ManifestFilename]
 	if !ok {
-		return errors.New("Gatecheck Bundle manifest not found")
+		return errors.New("gatecheck bundle manifest not found")
 	}
 	if err := json.Unmarshal(manifestBytes, manifest); err != nil {
 		return fmt.Errorf("gatecheck manifest decoding: %w", err)

pkg/archive/bundle_test.go

@@ -1,17 +1,13 @@
 package archive
 
 import (
-	"archive/tar"
 	"bytes"
-	"compress/gzip"
 	"errors"
-	"io"
 	"os"
 	"strings"
 	"testing"
 )
 
-
 func TestBundle_WriteFileTo(t *testing.T) {
 	bundle := NewBundle()
 	_ = bundle.AddFrom(strings.NewReader("ABCDEF"), "file-1.txt", nil)
@@ -48,24 +44,6 @@ func TestBundle_WriteFileTo(t *testing.T) {
 	})
 }
 
-func zippedTarballReader(r io.Reader, tarHeader *tar.Header) *bytes.Buffer {
-	outputBuf := new(bytes.Buffer)
-	gw := gzip.NewWriter(outputBuf)
-	tw := tar.NewWriter(gw)
-	_ = tw.WriteHeader(tarHeader)
-
-	_, _ = io.Copy(tw, r)
-	tw.Close()
-	gw.Close()
-	return outputBuf
-}
-
-type badReader struct{}
-
-func (r *badReader) Read(_ []byte) (int, error) {
-	return 0, errors.New("mock reader error")
-}
-
 type badWriter struct{}
 
 func (r *badWriter) Write(_ []byte) (int, error) {

pkg/artifacts/lcov.go

@@ -2,21 +2,11 @@ package artifacts
 
 import (
 	"errors"
-	"github.com/easy-up/go-coverage"
 	"log/slog"
 	"strings"
-)
 
-func example() (coverage.Report, error) {
-	lcovParser := coverage.New(coverage.LCOV)
-	report, err := lcovParser.Parse("./path/to/lcov.info")
-	if err != nil {
-		// Handle error
-		return coverage.Report{}, err
-	}
-	// Use the parsed report
-	return report, nil
-}
+	"github.com/easy-up/go-coverage"
+)
 
 func IsCoverageReport(inputFilename string) bool {
 	return strings.Contains(inputFilename, "lcov") ||

pkg/gatecheck/validate.go

@@ -5,20 +5,21 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/easy-up/go-coverage"
 	"io"
 	"log/slog"
 	"slices"
 	"sort"
 	"strings"
 
+	"github.com/easy-up/go-coverage"
+
 	"github.com/gatecheckdev/gatecheck/pkg/archive"
 	"github.com/gatecheckdev/gatecheck/pkg/artifacts"
 	"github.com/gatecheckdev/gatecheck/pkg/epss"
 	"github.com/gatecheckdev/gatecheck/pkg/kev"
 )
 
-var ErrValidationFailure = errors.New("Validation Failure")
+var ErrValidationFailure = errors.New("validation failure")
 
 func newValidationErr(details string) error {
 	return fmt.Errorf("%w: %s", ErrValidationFailure, details)
@@ -62,7 +63,7 @@ func Validate(config *Config, reportSrc io.Reader, targetFilename string, option
 
 	default:
 		slog.Error("unsupported file type, cannot be determined from filename", "filename", targetFilename)
-		return errors.New("Failed to validate artifact. See log for details.")
+		return errors.New("failed to validate artifact, See log for details")
 	}
 }
 
@@ -624,7 +625,7 @@ func validateGrypeReportWithFetch(r io.Reader, config *Config, options *fetchOpt
 
 	if err := LoadCatalogAndData(config, catalog, epssData, options); err != nil {
 		slog.Error("validate grype report: load epss data from file or api", "error", err)
-		return errors.New("Cannot run Grype validation: Cannot load external validation data. See log for details.")
+		return errors.New("cannot run Grype validation: Cannot load external validation data, see log for details")
 	}
 
 	return validateGrypeFrom(r, config, catalog, epssData)
@@ -635,7 +636,7 @@ func validateGrypeFrom(r io.Reader, config *Config, catalog *kev.Catalog, epssDa
 	report := &artifacts.GrypeReportMin{}
 	if err := json.NewDecoder(r).Decode(report); err != nil {
 		slog.Error("decode grype report for validation", "error", err)
-		return errors.New("Cannot run Grype validation: Report decoding failed. See log for details.")
+		return errors.New("cannot run Grype validation: Report decoding failed, See log for details")
 	}
 
 	return validateGrypeRules(config, report, catalog, epssData)
@@ -649,7 +650,7 @@ func validateCyclonedxReportWithFetch(r io.Reader, config *Config, options *fetc
 
 	if err := LoadCatalogAndData(config, catalog, epssData, options); err != nil {
 		slog.Error("validate cyclonedx report: load epss data from file or api", "error", err)
-		return errors.New("Cannot run Cyclonedx validation: Cannot load external validation data. See log for details.")
+		return errors.New("cannot run Cyclonedx validation: Cannot load external validation data, See log for details")
 	}
 	return validateCyclonedxFrom(r, config, catalog, epssData)
 }
@@ -658,7 +659,7 @@ func validateCyclonedxFrom(r io.Reader, config *Config, catalog *kev.Catalog, ep
 	report := &artifacts.CyclonedxReportMin{}
 	if err := json.NewDecoder(r).Decode(report); err != nil {
 		slog.Error("decode cyclonedx report for validation", "error", err)
-		return errors.New("Cannot run Cyclonedx validation: Report decoding failed. See log for details.")
+		return errors.New("cannot run Cyclonedx validation: Report decoding failed, See log for details")
 	}
 
 	return validateCyclonedxRules(config, report, catalog, epssData)
@@ -669,7 +670,7 @@ func validateSemgrepReport(r io.Reader, config *Config) error {
 	report := &artifacts.SemgrepReportMin{}
 	if err := json.NewDecoder(r).Decode(report); err != nil {
 		slog.Error("decode semgrep report for validation", "error", err)
-		return errors.New("Cannot run Semgrep report validation: Report decoding failed. See log for details.")
+		return errors.New("cannot run Semgrep report validation: Report decoding failed, See log for details")
 	}
 
 	return validateSemgrepRules(config, report)
@@ -680,7 +681,7 @@ func validateGitleaksReport(r io.Reader, config *Config) error {
 	report := &artifacts.GitLeaksReportMin{}
 	if err := json.NewDecoder(r).Decode(report); err != nil {
 		slog.Error("decode gitleaks report for validation", "error", err)
-		return errors.New("Cannot run Semgrep report validation: Report decoding failed. See log for details.")
+		return errors.New("cannot run Semgrep report validation: Report decoding failed, See log for details")
 	}
 	return validateGitleaksRules(config, report)
 }
@@ -736,15 +737,15 @@ func validateBundle(r io.Reader, config *Config, options *fetchOptions) error {
 	bundle := archive.NewBundle()
 	if err := archive.UntarGzipBundle(r, bundle); err != nil {
 		slog.Error("decode gatecheck bundle")
-		return errors.New("Cannot run Gatecheck Bundle validation: Bundle decoding failed. See log for details.")
+		return errors.New("cannot run Gatecheck Bundle validation: Bundle decoding failed, See log for details")
 	}
 
 	catalog := kev.NewCatalog()
 	epssData := new(epss.Data)
 
 	if err := LoadCatalogAndData(config, catalog, epssData, options); err != nil {
 		slog.Error("validate cyclonedx report: load epss data from file or api", "error", err)
-		return errors.New("Cannot run Cyclonedx validation: Cannot load external validation data. See log for details.")
+		return errors.New("cannot run Cyclonedx validation: Cannot load external validation data, See log for details")
 	}
 
 	var errs error