Refactor

Author: sonatard

README.md

@@ -32,41 +32,42 @@ analyzer:
       - description: "constraint directive exists on the input field"
         directive: constraint
         kind: ['INPUT_OBJECT']
+        field_parent_type: ['.+']
         field_type: ['^\[?Int\]?$', '^\[?Float\]?$', '^\[?String\]?$', '^\[?Decimal\]?$', '^\[?URL\]?$']
-        ignore_field: ['^first$', '^last$', '^after$', '^before$']
-        report_format: "%s.%s has no constraint directive"
+        exclude_field: ['^first$', '^last$', '^after$', '^before$']
+        report_format: "%s has no constraint directive"
     argument:
       - description: "constraint directive exists on the object field argument"
         directive: constraint
         kind: ['OBJECT']
         argument_type: ['^\[?Int\]?$', '^\[?Float\]?$', '^\[?String\]?$', '^\[?Decimal\]?$', '^\[?URL\]?$']
-        ignore_argument: ['^first$', '^last$', '^after$', '^before$']
-        report_format: "argument %s of %s has no constraint directive"
-
+        exclude_argument: ['^first$', '^last$', '^after$', '^before$']
+        report_format: "argument %s has no constraint directive"
 ```
 
-- sample2: permission directive exists on the type
+- sample2: permission directive exists on the definition
 
 ```yaml
 ---
 analyzer:
   - analyzer_name: "permission directive"
-    description: "permission directive exists on the type"
-    type:
-      - description: "permission directive exists on the type"
+    description: "permission directive exists on the definition"
+    definition:
+      - description: "permission directive exists on the definition"
         directive: permission
         kind: ['OBJECT', 'INTERFACE']
-        type: ['.+']
-        ignore_type: [ '^Query$', '^Mutation$', '^Subscription$', '^PageInfo$']
+        definition: ['.+']
+        exclude_definition: [ '^Query$', '^Mutation$', '^Subscription$', '^PageInfo$']
         report_format: "%s has no permission directive"
     field:
       - description: "permission directive exists on the mutation"
         directive: permission
         kind: ['OBJECT']
         field_parent_type:  ['^Mutation$']
         field_type: ['.+']
-        ignore_field:
-        report_format: "%s.%s has no permission directive"
+        exclude_field:
+        report_format: "%s has no permission directive"
+
 ```
 
 The `directive` command has a flag, `schema` which will be parsed and analyzed by directive's Analyzer.

analyzer.go

@@ -0,0 +1,111 @@
+package directive
+
+import (
+	"github.com/gqlgo/gqlanalysis"
+)
+
+func NewAnalyzers(config *Config) []*gqlanalysis.Analyzer {
+	analyzers := make([]*gqlanalysis.Analyzer, 0, len(config.Analyzer))
+	for _, analyzerConfig := range config.Analyzer {
+		analyzers = append(analyzers, NewAnalyzer(analyzerConfig))
+	}
+	return analyzers
+}
+
+func NewAnalyzer(analyzerConfig *AnalyzerConfig) *gqlanalysis.Analyzer {
+	return &gqlanalysis.Analyzer{
+		Name: analyzerConfig.AnalyzerName,
+		Doc:  analyzerConfig.Description,
+		Run:  MergeAnalyzers(analyzerConfig),
+	}
+}
+
+func MergeAnalyzers(analyzerConfig *AnalyzerConfig) func(pass *gqlanalysis.Pass) (any, error) {
+	var analyzers []*gqlanalysis.Analyzer
+	for _, c := range analyzerConfig.DefinitionConfig {
+		analyzer := DefinitionAnalyzer(c)
+		analyzers = append(analyzers, analyzer)
+	}
+	for _, c := range analyzerConfig.FieldConfig {
+		analyzer := FieldAnalyzer(c)
+		analyzers = append(analyzers, analyzer)
+	}
+	for _, c := range analyzerConfig.ArgumentConfig {
+		analyzer := ArgumentAnalyzer(c)
+		analyzers = append(analyzers, analyzer)
+	}
+	return func(pass *gqlanalysis.Pass) (any, error) {
+		for _, analyzer := range analyzers {
+			if _, err := analyzer.Run(pass); err != nil {
+				return nil, err
+			}
+		}
+		return nil, nil
+	}
+}
+
+func DefinitionAnalyzer(config *DefinitionConfig) *gqlanalysis.Analyzer {
+	return &gqlanalysis.Analyzer{
+		Name: config.Directive,
+		Doc:  config.Description,
+		Run: func(pass *gqlanalysis.Pass) (any, error) {
+			definitions := NewDefinitionsByMap(pass.Schema.Types).
+				NotBuildIn().
+				FilterByKinds(config.Kinds).
+				ExcludeByDefinitionName(config.ExcludeDefinitionPatterns).
+				FilterByNotHasDirective(config.Directive).
+				FilterByPositionNotNil()
+
+			for _, definition := range definitions {
+				pass.Reportf(definition.Position, config.ReportFormat, definition.Name)
+			}
+
+			return nil, nil
+		},
+	}
+}
+
+func FieldAnalyzer(config *FieldConfig) *gqlanalysis.Analyzer {
+	return &gqlanalysis.Analyzer{
+		Name: config.Directive,
+		Doc:  config.Description,
+		Run: func(pass *gqlanalysis.Pass) (any, error) {
+			definitions := NewDefinitionsByMap(pass.Schema.Types).
+				NotBuildIn().
+				FilterByKinds(config.Kinds).
+				FilterByDefinitionName(config.FieldParentTypePatterns)
+			fields := definitions.Fields().
+				FilterByFieldType(config.FieldTypePatterns).
+				ExcludeByField(config.ExcludeFieldPatterns).
+				FilterByNotHasDirective(config.Directive).
+				FilterByPositionNotNil()
+
+			for _, field := range fields {
+				pass.Reportf(field.Position, config.ReportFormat, field.Name)
+			}
+
+			return nil, nil
+		},
+	}
+}
+
+func ArgumentAnalyzer(config *ArgumentConfig) *gqlanalysis.Analyzer {
+	return &gqlanalysis.Analyzer{
+		Name: config.Directive,
+		Doc:  config.Description,
+		Run: func(pass *gqlanalysis.Pass) (any, error) {
+			definitions := NewDefinitionsByMap(pass.Schema.Types).NotBuildIn().FilterByKinds(config.Kinds)
+			fields := definitions.Fields().FilterByNotNil()
+			arguments := fields.Arguments().
+				FilterByArgumentType(config.ArgumentTypePatterns).
+				ExcludeByArgumentName(config.ExcludeArgumentPatterns).
+				FilterByNotHasDirective(config.Directive).
+				FilterByPositionNotNil()
+
+			for _, argument := range arguments {
+				pass.Reportf(argument.Position, config.ReportFormat, argument.Name)
+			}
+			return nil, nil
+		},
+	}
+}

directive_test.go renamed to analyzer_test.go

@@ -0,0 +1,53 @@
+package directive
+
+import (
+	"github.com/vektah/gqlparser/v2/ast"
+	"slices"
+)
+
+type ArgumentDefinitions ast.ArgumentDefinitionList
+
+func (as ArgumentDefinitions) FilterByArgumentType(argumentTypePatterns []string) ArgumentDefinitions {
+	var arguments ArgumentDefinitions
+	for _, argument := range as {
+		if slices.ContainsFunc(argumentTypePatterns, func(pattern string) bool { return isType(pattern, argument.Type) }) {
+			arguments = append(arguments, argument)
+		}
+	}
+
+	return arguments
+}
+
+func (as ArgumentDefinitions) ExcludeByArgumentName(excludeArgumentPatterns []string) ArgumentDefinitions {
+	var arguments ArgumentDefinitions
+	for _, argument := range as {
+		if !slices.ContainsFunc(excludeArgumentPatterns, func(pattern string) bool { return isMatch(pattern, argument.Name) }) {
+			arguments = append(arguments, argument)
+		}
+	}
+	return arguments
+}
+
+func (as ArgumentDefinitions) FilterByNotHasDirective(directive string) ArgumentDefinitions {
+	var arguments ArgumentDefinitions
+	for _, argument := range as {
+		if !findDirectiveOnArgument(argument, directive) {
+			arguments = append(arguments, argument)
+		}
+	}
+	return arguments
+}
+
+func (as ArgumentDefinitions) FilterByPositionNotNil() ArgumentDefinitions {
+	var arguments ArgumentDefinitions
+	for _, argument := range as {
+		if argument.Position != nil {
+			arguments = append(arguments, argument)
+		}
+	}
+	return arguments
+}
+
+func findDirectiveOnArgument(argument *ast.ArgumentDefinition, directiveName string) bool {
+	return argument.Directives.ForName(directiveName) != nil
+}

argument.go

@@ -1,118 +1,9 @@
 package directive
 
 import (
-	"fmt"
-	"github.com/vektah/gqlparser/v2/ast"
 	"regexp"
-	"slices"
 )
 
-func targetTypeKind(types map[string]*ast.Definition, kinds []ast.DefinitionKind) []*ast.Definition {
-	var targets []*ast.Definition
-	for _, t := range types {
-		if !t.BuiltIn && slices.Contains(kinds, t.Kind) {
-			targets = append(targets, t)
-		}
-	}
-	return targets
-}
-
-func targetTypes(types ast.DefinitionList, fieldParentTypePatterns []string) ast.DefinitionList {
-	var targets ast.DefinitionList
-	for _, t := range types {
-		if slices.ContainsFunc(fieldParentTypePatterns, func(pattern string) bool { return isNameMatch(pattern, t.Name) }) {
-			targets = append(targets, t)
-		}
-	}
-	return targets
-}
-
-func targetFieldType(fields ast.FieldList, fieldTypePatterns []string) ast.FieldList {
-	var targets ast.FieldList
-	for _, field := range fields {
-		if field != nil && field.Type != nil {
-			if slices.ContainsFunc(fieldTypePatterns, func(pattern string) bool { return isType(pattern, field.Type) }) {
-				targets = append(targets, field)
-			}
-		}
-	}
-	return targets
-}
-
-func excludeTargetFieldTypeByTypeName(fields ast.FieldList, ignoreFiledNamePatterns []string) ast.FieldList {
-	var targets ast.FieldList
-	for _, field := range fields {
-		if field != nil && field.Type != nil {
-			if !slices.ContainsFunc(ignoreFiledNamePatterns, func(pattern string) bool { return isNameMatch(pattern, field.Name) }) {
-				targets = append(targets, field)
-			}
-		}
-	}
-	return targets
-}
-
-func targetFieldArgumentType(field *ast.FieldDefinition, fieldArgumentTypePatterns []string) ast.ArgumentDefinitionList {
-	var targets ast.ArgumentDefinitionList
-	if field != nil && field.Type != nil {
-		for _, arg := range field.Arguments {
-			if slices.ContainsFunc(fieldArgumentTypePatterns, func(pattern string) bool { return isType(pattern, arg.Type) }) {
-				targets = append(targets, arg)
-			}
-		}
-	}
-	return targets
-}
-
-func excludeTargetArgumentsByField(args ast.ArgumentDefinitionList, ignoreArgumentPatterns []string) ast.ArgumentDefinitionList {
-	var targets ast.ArgumentDefinitionList
-	for _, arg := range args {
-		if !slices.ContainsFunc(ignoreArgumentPatterns, func(pattern string) bool { return isNameMatch(pattern, arg.Name) }) {
-			targets = append(targets, arg)
-		}
-	}
-	return targets
-}
-
-func excludeTargetTypesByTypeName(types ast.DefinitionList, ignoreTypePatterns []string) ast.DefinitionList {
-	var targets ast.DefinitionList
-	for _, t := range types {
-		if !slices.ContainsFunc(ignoreTypePatterns, func(pattern string) bool { return isNameMatch(pattern, t.Name) }) {
-			targets = append(targets, t)
-		}
-	}
-	return targets
-}
-
-func findDirectiveOnDefinition(t *ast.Definition, directiveName string) bool {
-	return t.Directives.ForName(directiveName) != nil
-}
-
-func findDirectiveOnField(field *ast.FieldDefinition, directiveName string) bool {
-	return field.Directives.ForName(directiveName) != nil
-}
-
-func findDirectiveOnArg(arg *ast.ArgumentDefinition, directiveName string) bool {
-	return arg.Directives.ForName(directiveName) != nil
-}
-
-func isType(pattern string, t *ast.Type) bool {
-	if t == nil {
-		return false
-	}
-	return isNameMatch(pattern, typeName(t))
-}
-
-func isNameMatch(pattern, name string) bool {
+func isMatch(pattern, name string) bool {
 	return regexp.MustCompile(pattern).MatchString(name)
 }
-
-func typeName(t *ast.Type) string {
-	if isList(t) {
-		return fmt.Sprintf("[%s]", t.Elem.NamedType)
-	}
-	return t.NamedType
-}
-
-func isList(t *ast.Type) bool {
-	return t.Elem != nil
-}

common.go

@@ -105,7 +105,7 @@ func Test_isNameMatch(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := isNameMatch(tt.args.pattern, tt.args.typeName); got != tt.want {
+			if got := isMatch(tt.args.pattern, tt.args.typeName); got != tt.want {
 				t.Errorf("isTypeNameMatch() = %v, want %v", got, tt.want)
 			}
 		})