refactor: make lint use more accessible data type (#2660)

src/cmd/dev.go

@@ -18,7 +18,6 @@ import (
  "github.com/defenseunicorns/zarf/src/config/lang"
  "github.com/defenseunicorns/zarf/src/pkg/message"
  "github.com/defenseunicorns/zarf/src/pkg/packager"
- "github.com/defenseunicorns/zarf/src/pkg/packager/lint"
  "github.com/defenseunicorns/zarf/src/pkg/transform"
  "github.com/defenseunicorns/zarf/src/pkg/utils"
  "github.com/defenseunicorns/zarf/src/types"
@@ -249,19 +248,19 @@ var devLintCmd = &cobra.Command{
  Aliases: []string{"l"},
  Short: lang.CmdDevLintShort,
  Long: lang.CmdDevLintLong,
- Run: func(cmd *cobra.Command, args []string) {
+ RunE: func(cmd *cobra.Command, args []string) error {
  pkgConfig.CreateOpts.BaseDir = common.SetBaseDirectory(args)
  v := common.GetViper()
  pkgConfig.CreateOpts.SetVariables = helpers.TransformAndMergeMap(
  v.GetStringMapString(common.VPkgCreateSet), pkgConfig.CreateOpts.SetVariables, strings.ToUpper)
- validator, err := lint.Validate(cmd.Context(), pkgConfig.CreateOpts)
+
+ pkgClient, err := packager.New(&pkgConfig)
  if err != nil {
- message.Fatal(err, err.Error())
- }
- validator.DisplayFormattedMessage()
- if !validator.IsSuccess() {
- os.Exit(1)
+ return err
  }
+ defer pkgClient.ClearTempPaths()
+
+ return pkgClient.Lint(cmd.Context())
  },
 }
 

src/pkg/message/message.go

@@ -327,7 +327,7 @@ func Table(header []string, data [][]string) {
 // preventing future characters from taking on the given color
 // returns string as normal if color is disabled
 func ColorWrap(str string, attr color.Attribute) string {
- if config.NoColor {
+ if config.NoColor || str == "" {
  return str
  }
  return fmt.Sprintf("\x1b[%dm%s\x1b[0m", attr, str)

src/pkg/packager/dev.go

@@ -6,8 +6,10 @@ package packager
 
 import (
  "context"
+ "errors"
  "fmt"
  "os"
+ "path/filepath"
  "runtime"
 
  "github.com/defenseunicorns/pkg/helpers/v2"
@@ -16,7 +18,10 @@ import (
  "github.com/defenseunicorns/zarf/src/pkg/message"
  "github.com/defenseunicorns/zarf/src/pkg/packager/creator"
  "github.com/defenseunicorns/zarf/src/pkg/packager/filters"
+ "github.com/defenseunicorns/zarf/src/pkg/packager/lint"
+ "github.com/defenseunicorns/zarf/src/pkg/utils"
  "github.com/defenseunicorns/zarf/src/types"
+ "github.com/fatih/color"
 )
 
 // DevDeploy creates + deploys a package in one shot
@@ -105,3 +110,69 @@ func (p *Packager) DevDeploy(ctx context.Context) error {
  // cd back
  return os.Chdir(cwd)
 }
+
+// Lint ensures a package is valid & follows suggested conventions
+func (p *Packager) Lint(ctx context.Context) error {
+ if err := os.Chdir(p.cfg.CreateOpts.BaseDir); err != nil {
+ return fmt.Errorf("unable to access directory %q: %w", p.cfg.CreateOpts.BaseDir, err)
+ }
+
+ if err := utils.ReadYaml(layout.ZarfYAML, &p.cfg.Pkg); err != nil {
+ return err
+ }
+
+ findings, err := lint.Validate(ctx, p.cfg.Pkg, p.cfg.CreateOpts)
+ if err != nil {
+ return fmt.Errorf("linting failed: %w", err)
+ }
+
+ if len(findings) == 0 {
+ message.Successf("0 findings for %q", p.cfg.Pkg.Metadata.Name)
+ return nil
+ }
+
+ mapOfFindingsByPath := lint.GroupFindingsByPath(findings, types.SevWarn, p.cfg.Pkg.Metadata.Name)
+
+ header := []string{"Type", "Path", "Message"}
+
+ for _, findings := range mapOfFindingsByPath {
+ lintData := [][]string{}
+ for _, finding := range findings {
+ lintData = append(lintData, []string{
+ colorWrapSev(finding.Severity),
+ message.ColorWrap(finding.YqPath, color.FgCyan),
+ itemizedDescription(finding.Description, finding.Item),
+ })
+ }
+ var packagePathFromUser string
+ if helpers.IsOCIURL(findings[0].PackagePathOverride) {
+ packagePathFromUser = findings[0].PackagePathOverride
+ } else {
+ packagePathFromUser = filepath.Join(p.cfg.CreateOpts.BaseDir, findings[0].PackagePathOverride)
+ }
+ message.Notef("Linting package %q at %s", findings[0].PackageNameOverride, packagePathFromUser)
+ message.Table(header, lintData)
+ }
+
+ if lint.HasSeverity(findings, types.SevErr) {
+ return errors.New("errors during lint")
+ }
+
+ return nil
+}
+
+func itemizedDescription(description string, item string) string {
+ if item == "" {
+ return description
+ }
+ return fmt.Sprintf("%s - %s", description, item)
+}
+
+func colorWrapSev(s types.Severity) string {
+ if s == types.SevErr {
+ return message.ColorWrap("Error", color.FgRed)
+ } else if s == types.SevWarn {
+ return message.ColorWrap("Warning", color.FgYellow)
+ }
+ return "unknown"
+}

src/pkg/packager/lint/findings.go

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2021-Present The Zarf Authors
+
+// Package lint contains functions for verifying zarf yaml files are valid
+package lint
+
+import (
+ "github.com/defenseunicorns/pkg/helpers/v2"
+ "github.com/defenseunicorns/zarf/src/types"
+)
+
+// GroupFindingsByPath groups findings by their package path
+func GroupFindingsByPath(findings []types.PackageFinding, severity types.Severity, packageName string) map[string][]types.PackageFinding {
+ findings = helpers.RemoveMatches(findings, func(finding types.PackageFinding) bool {
+ return finding.Severity > severity
+ })
+ for i := range findings {
+ if findings[i].PackageNameOverride == "" {
+ findings[i].PackageNameOverride = packageName
+ }
+ if findings[i].PackagePathOverride == "" {
+ findings[i].PackagePathOverride = "."
+ }
+ }
+
+ mapOfFindingsByPath := make(map[string][]types.PackageFinding)
+ for _, finding := range findings {
+ mapOfFindingsByPath[finding.PackagePathOverride] = append(mapOfFindingsByPath[finding.PackagePathOverride], finding)
+ }
+ return mapOfFindingsByPath
+}
+
+// HasSeverity returns true if the findings contain a severity equal to or greater than the given severity
+func HasSeverity(findings []types.PackageFinding, severity types.Severity) bool {
+ for _, finding := range findings {
+ if finding.Severity <= severity {
+ return true
+ }
+ }
+ return false
+}

src/pkg/packager/lint/findings_test.go

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2021-Present The Zarf Authors
+
+// Package lint contains functions for verifying zarf yaml files are valid
+package lint
+
+import (
+ "testing"
+
+ "github.com/defenseunicorns/zarf/src/types"
+ "github.com/stretchr/testify/require"
+)
+
+func TestGroupFindingsByPath(t *testing.T) {
+ t.Parallel()
+ tests := []struct {
+ name string
+ findings []types.PackageFinding
+ severity types.Severity
+ packageName string
+ want map[string][]types.PackageFinding
+ }{
+ {
+ name: "same package multiple findings",
+ findings: []types.PackageFinding{
+ {Severity: types.SevWarn, PackageNameOverride: "import", PackagePathOverride: "path"},
+ {Severity: types.SevWarn, PackageNameOverride: "import", PackagePathOverride: "path"},
+ },
+ severity: types.SevWarn,
+ packageName: "testPackage",
+ want: map[string][]types.PackageFinding{
+ "path": {
+ {Severity: types.SevWarn, PackageNameOverride: "import", PackagePathOverride: "path"},
+ {Severity: types.SevWarn, PackageNameOverride: "import", PackagePathOverride: "path"},
+ },
+ },
+ },
+ {
+ name: "different packages single finding",
+ findings: []types.PackageFinding{
+ {Severity: types.SevWarn, PackageNameOverride: "import", PackagePathOverride: "path"},
+ {Severity: types.SevErr, PackageNameOverride: "", PackagePathOverride: ""},
+ },
+ severity: types.SevWarn,
+ packageName: "testPackage",
+ want: map[string][]types.PackageFinding{
+ "path": {{Severity: types.SevWarn, PackageNameOverride: "import", PackagePathOverride: "path"}},
+ ".": {{Severity: types.SevErr, PackageNameOverride: "testPackage", PackagePathOverride: "."}},
+ },
+ },
+ {
+ name: "Multiple findings, mixed severity",
+ findings: []types.PackageFinding{
+ {Severity: types.SevWarn, PackageNameOverride: "", PackagePathOverride: ""},
+ {Severity: types.SevErr, PackageNameOverride: "", PackagePathOverride: ""},
+ },
+ severity: types.SevErr,
+ packageName: "testPackage",
+ want: map[string][]types.PackageFinding{
+ ".": {{Severity: types.SevErr, PackageNameOverride: "testPackage", PackagePathOverride: "."}},
+ },
+ },
+ }
+ for _, tt := range tests {
+ tt := tt
+ t.Run(tt.name, func(t *testing.T) {
+ t.Parallel()
+ require.Equal(t, tt.want, GroupFindingsByPath(tt.findings, tt.severity, tt.packageName))
+ })
+ }
+}
+
+func TestHasSeverity(t *testing.T) {
+ t.Parallel()
+ tests := []struct {
+ name string
+ severity types.Severity
+ expected bool
+ findings []types.PackageFinding
+ }{
+ {
+ name: "error severity present",
+ findings: []types.PackageFinding{
+ {
+ Severity: types.SevErr,
+ },
+ },
+ severity: types.SevErr,
+ expected: true,
+ },
+ {
+ name: "error severity not present",
+ findings: []types.PackageFinding{
+ {
+ Severity: types.SevWarn,
+ },
+ },
+ severity: types.SevErr,
+ expected: false,
+ },
+ {
+ name: "err and warning severity present",
+ findings: []types.PackageFinding{
+ {
+ Severity: types.SevWarn,
+ },
+ {
+ Severity: types.SevErr,
+ },
+ },
+ severity: types.SevErr,
+ expected: true,
+ },
+ }
+ for _, tt := range tests {
+ tt := tt
+ t.Run(tt.name, func(t *testing.T) {
+ t.Parallel()
+ require.Equal(t, tt.expected, HasSeverity(tt.findings, tt.severity))
+ })
+ }
+}