Adds nophase linter

README.md

@@ -154,6 +154,10 @@ lintersConfig:
     jsonTagRegex: "^[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$" # Provide a custom regex, which the json tag must match.
 ```
 
+## Nophase
+
+The `nophase` linter checks that the fields in the API types don't contain a 'Phase', or any field which contains 'Phase' as a substring, e.g MachinePhase.
+
 ## OptionalOrRequired
 
 The `optionalorrequired` linter checks that all fields in the API types are either optional or required, and are marked explicitly as such.

docs/new-linter.md

@@ -132,7 +132,9 @@ Basic tests can be implemented with the Go analysis test framework.
 Create a `testdata` directory in the linter package and create a structure underneath.
 Individual test files must be placed under `src` and then a subdirectory for each package.
 
-Use one package per configuration input for the linter.
+If your linter has different configurations, e.g options to pass to the linter
+you will need one configuration per option. Use one package per configuration
+input for the linter.
 
 ```
 mylinter

pkg/analysis/nophase/analyzer.go

@@ -0,0 +1,91 @@
+package nophase
+
+import (
+	"errors"
+	"go/ast"
+	"strings"
+
+	"github.com/JoelSpeed/kal/pkg/analysis/helpers/extractjsontags"
+	"golang.org/x/tools/go/analysis"
+	"golang.org/x/tools/go/analysis/passes/inspect"
+	"golang.org/x/tools/go/ast/inspector"
+)
+
+const name = "nophase"
+
+var (
+	errCouldNotGetInspector = errors.New("could not get inspector")
+	errCouldNotGetJSONTags  = errors.New("could not get json tags")
+)
+
+// Analyzer is the analyzer for the nophase package.
+// It checks that no struct fields named 'phase', or that contain phase as a
+// substring are present.
+var Analyzer = &analysis.Analyzer{
+	Name:     name,
+	Doc:      "phase fields are deprecated and conditions should be preferred, avoid phase like enum fields",
+	Run:      run,
+	Requires: []*analysis.Analyzer{inspect.Analyzer, extractjsontags.Analyzer},
+}
+
+func run(pass *analysis.Pass) (interface{}, error) {
+	inspect, ok := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
+	if !ok {
+		return nil, errCouldNotGetInspector
+	}
+
+	jsonTags, ok := pass.ResultOf[extractjsontags.Analyzer].(extractjsontags.StructFieldTags)
+	if !ok {
+		return nil, errCouldNotGetJSONTags
+	}
+
+	// Filter to structs so that we can iterate over fields in a struct.
+	nodeFilter := []ast.Node{
+		(*ast.StructType)(nil),
+	}
+
+	// Preorder visits all the nodes of the AST in depth-first order. It calls
+	// f(n) for each node n before it visits n's children.
+	//
+	// We use the filter defined above, ensuring we only look at struct fields.
+	inspect.Preorder(nodeFilter, func(n ast.Node) {
+		sTyp, ok := n.(*ast.StructType)
+		if !ok {
+			return
+		}
+
+		if sTyp.Fields == nil {
+			return
+		}
+
+		for _, field := range sTyp.Fields.List {
+			if field == nil || len(field.Names) == 0 {
+				continue
+			}
+
+			fieldName := field.Names[0].Name
+
+			// First check if the struct field name contains 'phase'
+			if strings.Contains(strings.ToLower(fieldName), "phase") {
+				pass.Reportf(field.Pos(),
+					"field %s: phase fields are deprecated and conditions should be preferred, avoid phase like enum fields",
+					fieldName,
+				)
+
+				continue
+			}
+
+			// Then check if the json serialization of the field contains 'phase'
+			tagInfo := jsonTags.FieldTags(sTyp, fieldName)
+
+			if strings.Contains(strings.ToLower(tagInfo.Name), "phase") {
+				pass.Reportf(field.Pos(),
+					"field %s: phase fields are deprecated and conditions should be preferred, avoid phase like enum fields",
+					fieldName,
+				)
+			}
+		}
+	})
+
+	return nil, nil //nolint:nilnil
+}

pkg/analysis/nophase/analyzer_test.go

@@ -0,0 +1,13 @@
+package nophase_test
+
+import (
+	"testing"
+
+	"github.com/JoelSpeed/kal/pkg/analysis/nophase"
+	"golang.org/x/tools/go/analysis/analysistest"
+)
+
+func Test(t *testing.T) {
+	testdata := analysistest.TestData()
+	analysistest.RunWithSuggestedFixes(t, testdata, nophase.Analyzer, "a")
+}

pkg/analysis/nophase/doc.go

@@ -0,0 +1,11 @@
+/*
+nophase provides a linter to ensure that structs do not contain a Phase field.
+
+Phase fields are deprecated and conditions should be preferred. Avoid phase like enum
+fields.
+
+The linter will flag any struct field containing the substring 'phase'. This means both
+Phase and FooPhase will be flagged.
+*/
+
+package nophase

pkg/analysis/nophase/initializer.go

@@ -0,0 +1,30 @@
+package nophase
+
+import (
+	"github.com/JoelSpeed/kal/pkg/config"
+	"golang.org/x/tools/go/analysis"
+)
+
+// Initializer returns the AnalyzerInitializer for this
+// Analyzer so that it can be added to the registry.
+func Initializer() initializer {
+	return initializer{}
+}
+
+// intializer implements the AnalyzerInitializer interface.
+type initializer struct{}
+
+// Name returns the name of the Analyzer.
+func (initializer) Name() string {
+	return name
+}
+
+// Init returns the intialized Analyzer.
+func (initializer) Init(cfg config.LintersConfig) (*analysis.Analyzer, error) {
+	return Analyzer, nil
+}
+
+// Default determines whether this Analyzer is on by default, or not.
+func (initializer) Default() bool {
+	return true
+}

pkg/analysis/nophase/testdata/src/a/a.go

@@ -0,0 +1,19 @@
+package a
+
+type NoPhaseTestStruct struct {
+	// +optional
+	Phase *string `json:"phase,omitempty"` // want "field Phase: phase fields are deprecated and conditions should be preferred, avoid phase like enum fields"
+
+}
+
+type NoSubPhaseTestStruct struct {
+	// +optional
+	FooPhase *string `json:"fooPhase,omitempty"` // want "field FooPhase: phase fields are deprecated and conditions should be preferred, avoid phase like enum fields"
+
+}
+
+type SerializedPhaseTeststruct struct {
+	// +optional
+	FooField *string `json:"fooPhase,omitempty"` // want "field FooField: phase fields are deprecated and conditions should be preferred, avoid phase like enum fields"
+
+}

pkg/analysis/registry.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/JoelSpeed/kal/pkg/analysis/commentstart"
 	"github.com/JoelSpeed/kal/pkg/analysis/jsontags"
+	"github.com/JoelSpeed/kal/pkg/analysis/nophase"
 	"github.com/JoelSpeed/kal/pkg/analysis/optionalorrequired"
 	"github.com/JoelSpeed/kal/pkg/analysis/requiredfields"
 	"github.com/JoelSpeed/kal/pkg/config"
@@ -51,6 +52,7 @@ func NewRegistry() Registry {
 		initializers: []AnalyzerInitializer{
 			commentstart.Initializer(),
 			jsontags.Initializer(),
+			nophase.Initializer(),
 			optionalorrequired.Initializer(),
 			requiredfields.Initializer(),
 		},

pkg/analysis/registry_test.go

@@ -18,6 +18,7 @@ var _ = Describe("Registry", func() {
 			Expect(r.DefaultLinters().UnsortedList()).To(ConsistOf(
 				"commentstart",
 				"jsontags",
+				"nophase",
 				"optionalorrequired",
 				"requiredfields",
 			))
@@ -30,6 +31,7 @@ var _ = Describe("Registry", func() {
 			Expect(r.AllLinters().UnsortedList()).To(ConsistOf(
 				"commentstart",
 				"jsontags",
+				"nophase",
 				"optionalorrequired",
 				"requiredfields",
 			))