nophase: wrap namingconventions linter

Signed-off-by: Bryce Palmer <bpalmer@redhat.com>

Author: everettraven

pkg/analysis/nophase/analyzer.go

@@ -16,81 +16,51 @@ limitations under the License.
 package nophase
 
 import (
-	"go/ast"
-	"strings"
+	"errors"
+	"fmt"
 
 	"golang.org/x/tools/go/analysis"
-	"golang.org/x/tools/go/analysis/passes/inspect"
-	"golang.org/x/tools/go/ast/inspector"
-	kalerrors "sigs.k8s.io/kube-api-linter/pkg/analysis/errors"
-	"sigs.k8s.io/kube-api-linter/pkg/analysis/helpers/extractjsontags"
-	"sigs.k8s.io/kube-api-linter/pkg/analysis/utils"
+	"k8s.io/apimachinery/pkg/util/validation/field"
+	"sigs.k8s.io/kube-api-linter/pkg/analysis/initializer"
+	"sigs.k8s.io/kube-api-linter/pkg/analysis/namingconventions"
 )
 
-const name = "nophase"
-
-// 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},
-}
+const (
+	name = "nophase"
+	doc  = "phase fields are deprecated and conditions should be preferred, avoid phase like enum fields"
+)
 
-func run(pass *analysis.Pass) (any, error) {
-	inspect, ok := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
-	if !ok {
-		return nil, kalerrors.ErrCouldNotGetInspector
+var errUnexpectedInitializerType = errors.New("expected namingconventions.Initializer() to be of type initializer.ConfigurableAnalyzerInitializer, but was not")
+
+func newAnalyzer() *analysis.Analyzer {
+	cfg := &namingconventions.Config{
+		Conventions: []namingconventions.Convention{
+			{
+				Name:             "nophase",
+				ViolationMatcher: "(?i)phase",
+				Operation:        namingconventions.OperationInform,
+				Message:          "phase fields are deprecated and conditions should be preferred, avoid phase like enum fields",
+			},
+		},
 	}
 
-	jsonTags, ok := pass.ResultOf[extractjsontags.Analyzer].(extractjsontags.StructFieldTags)
+	configInit, ok := namingconventions.Initializer().(initializer.ConfigurableAnalyzerInitializer)
 	if !ok {
-		return nil, kalerrors.ErrCouldNotGetJSONTags
+		panic(fmt.Errorf("getting initializer: %w", errUnexpectedInitializerType))
 	}
 
-	// Filter to fields so that we can iterate over fields in a struct.
-	nodeFilter := []ast.Node{
-		(*ast.Field)(nil),
+	errs := configInit.ValidateConfig(cfg, field.NewPath("nophase"))
+	if err := errs.ToAggregate(); err != nil {
+		panic(fmt.Errorf("nophase linter has an invalid namingconventions configuration: %w", err))
 	}
 
-	// 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) {
-		field, ok := n.(*ast.Field)
-		if !ok {
-			return
-		}
-
-		if field == nil || len(field.Names) == 0 {
-			return
-		}
-
-		fieldName := utils.FieldName(field)
-
-		// 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,
-			)
-
-			return
-		}
-
-		// Then check if the json serialization of the field contains 'phase'
-		tagInfo := jsonTags.FieldTags(field)
+	analyzer, err := configInit.Init(cfg)
+	if err != nil {
+		panic(fmt.Errorf("nophase linter encountered an error initializing wrapped namingconventions analyzer: %w", err))
+	}
 
-		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,
-			)
-		}
-	})
+	analyzer.Name = name
+	analyzer.Doc = doc
 
-	return nil, nil //nolint:nilnil
+	return analyzer
 }

pkg/analysis/nophase/analyzer_test.go

@@ -13,16 +13,15 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
-package nophase_test
+package nophase
 
 import (
 	"testing"
 
 	"golang.org/x/tools/go/analysis/analysistest"
-	"sigs.k8s.io/kube-api-linter/pkg/analysis/nophase"
 )
 
 func Test(t *testing.T) {
 	testdata := analysistest.TestData()
-	analysistest.RunWithSuggestedFixes(t, testdata, nophase.Analyzer, "a")
+	analysistest.RunWithSuggestedFixes(t, testdata, newAnalyzer(), "a")
 }

pkg/analysis/nophase/initializer.go

@@ -29,7 +29,7 @@ func init() {
 func Initializer() initializer.AnalyzerInitializer {
 	return initializer.NewInitializer(
 		name,
-		Analyzer,
+		newAnalyzer(),
 		true,
 	)
 }

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

@@ -2,21 +2,18 @@ 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"
-
+	Phase *string `json:"phase,omitempty"` // want "naming convention \"nophase\": phase fields are deprecated and conditions should be preferred, avoid phase like enum fields"
 }
 
 // DoNothing is used to check that the analyser doesn't report on methods.
 func (NoPhaseTestStruct) DoNothing() {}
 
 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"
-
+	FooPhase *string `json:"fooPhase,omitempty"` // want "naming convention \"nophase\": 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"
-
+	FooField *string `json:"fooPhase,omitempty"` // want "naming convention \"nophase\": phase fields are deprecated and conditions should be preferred, avoid phase like enum fields"
 }