refactor to avoid cyclop

Signed-off-by: sivchari <shibuuuu5@gmail.com>

Author: sivchari

pkg/analysis/helpers/inspector/inspector.go

@@ -66,65 +66,69 @@ func (i *inspector) InspectFields(inspectField func(field *ast.Field, stack []as
 			return false
 		}
 
-		if len(stack) < 3 {
-			return true
+		field, ok := n.(*ast.Field)
+		if !ok || !i.shouldProcessField(stack) {
+			return ok
 		}
 
-		// The 0th node in the stack is the *ast.File.
-		// The 1st node in the stack is the *ast.GenDecl.
-		decl, ok := stack[1].(*ast.GenDecl)
-		if !ok {
-			// Make sure that we don't inspect structs within a function.
+		if i.shouldSkipField(field) {
 			return false
 		}
 
-		if decl.Tok != token.TYPE {
-			// Returning false here means we won't inspect non-type declarations (e.g. var, const, import).
-			return false
-		}
+		i.processFieldWithRecovery(field, stack, inspectField)
 
-		structType, ok := stack[len(stack)-3].(*ast.StructType)
-		if !ok {
-			// A field within a struct has a FieldList parent and then a StructType parent.
-			// If we don't have a StructType parent, then we're not in a struct.
-			return false
-		}
+		return true
+	})
+}
 
-		if isItemsType(structType) {
-			// The field belongs to an items type, we don't need to report lint errors for this.
-			return false
-		}
+// shouldProcessField checks if the field should be processed.
+func (i *inspector) shouldProcessField(stack []ast.Node) bool {
+	if len(stack) < 3 {
+		return false
+	}
 
-		field, ok := n.(*ast.Field)
-		if !ok {
-			return true
-		}
+	// The 0th node in the stack is the *ast.File.
+	// The 1st node in the stack is the *ast.GenDecl.
+	decl, ok := stack[1].(*ast.GenDecl)
+	if !ok || decl.Tok != token.TYPE {
+		// Make sure that we don't inspect structs within a function or non-type declarations.
+		return false
+	}
 
-		tagInfo := i.jsonTags.FieldTags(field)
-		if tagInfo.Ignored {
-			// Returning false here means we won't inspect the children of an ignored field.
-			return false
-		}
+	structType, ok := stack[len(stack)-3].(*ast.StructType)
+	if !ok || isItemsType(structType) {
+		// Not in a struct or belongs to an items type.
+		return false
+	}
 
-		markerSet := i.markers.FieldMarkers(field)
+	return true
+}
 
-		if isSchemalessType(markerSet) {
-			// If the field is marked as schemaless, we don't need to inspect it.
-			return false
-		}
+// shouldSkipField checks if a field should be skipped.
+func (i *inspector) shouldSkipField(field *ast.Field) bool {
+	tagInfo := i.jsonTags.FieldTags(field)
+	if tagInfo.Ignored {
+		return true
+	}
 
-		defer func() {
-			if r := recover(); r != nil {
-				// If the inspectField function panics, we recover and log information that will help identify the issue.
-				debug := printDebugInfo(field)
-				panic(fmt.Sprintf("%s %v", debug, r)) // Re-panic to propagate the error.
-			}
-		}()
+	markerSet := i.markers.FieldMarkers(field)
 
-		inspectField(field, stack, tagInfo, i.markers)
+	return isSchemalessType(markerSet)
+}
 
-		return true
-	})
+// processFieldWithRecovery processes a field with panic recovery.
+func (i *inspector) processFieldWithRecovery(field *ast.Field, stack []ast.Node, inspectField func(field *ast.Field, stack []ast.Node, jsonTagInfo extractjsontags.FieldTagInfo, markersAccess markers.Markers)) {
+	tagInfo := i.jsonTags.FieldTags(field)
+
+	defer func() {
+		if r := recover(); r != nil {
+			// If the inspectField function panics, we recover and log information that will help identify the issue.
+			debug := printDebugInfo(field)
+			panic(fmt.Sprintf("%s %v", debug, r)) // Re-panic to propagate the error.
+		}
+	}()
+
+	inspectField(field, stack, tagInfo, i.markers)
 }
 
 // InspectTypeSpec inspects the type spec and calls the provided inspectTypeSpec function.