Exclude markdown tables for field markets.

add a test case demonstrating bug for markdown tables

Use robust regex pattern for marker validation

Address PR review feedback to validate markers more precisely.
Instead of only checking if a marker starts with a letter,
now validate the entire marker content to exclude markdown tables
and other non-marker patterns while supporting complex validation
tags with parentheses and nested expressions.

Add comprehensive test cases in analyzer_test.go to verify that:
- Valid markers (including complex nested expressions) are recognized
- Invalid patterns (markdown tables, special characters) are excluded

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: kannon92

pkg/analysis/helpers/markers/analyzer.go

@@ -201,12 +201,26 @@ func extractFieldMarkers(field *ast.Field, results *markers) {
 	results.insertFieldMarkers(field, fieldMarkers)
 }
 
+// validMarkerStart validates that a marker starts with an alphabetic character
+// and contains only valid marker content (letters, numbers, colons, parentheses, quotes, spaces, and commas).
+// This excludes markdown tables (e.g., "-------") and other non-marker content,
+// while supporting declarative validation tags with parentheses and nested markers.
+var validMarkerStart = regexp.MustCompile(`^[a-zA-Z]([a-zA-Z0-9:\(\)\"\" ,])+=?`)
+
 func extractMarker(comment *ast.Comment) Marker {
 	if !strings.HasPrefix(comment.Text, "// +") {
 		return Marker{}
 	}
 
 	markerContent := strings.TrimPrefix(comment.Text, "// +")
+
+	// Valid markers must start with an alphabetic character (a-zA-Z).
+	// This excludes markdown tables (e.g., "// +-------") and other non-marker content,
+	// while supporting declarative validation tags that may include parentheses and nested markers.
+	if !validMarkerStart.MatchString(markerContent) {
+		return Marker{}
+	}
+
 	id, expressions := extractMarkerIDAndExpressions(DefaultRegistry(), markerContent)
 
 	return Marker{

pkg/analysis/helpers/markers/analyzer_test.go

@@ -16,6 +16,7 @@ limitations under the License.
 package markers
 
 import (
+	"go/ast"
 	"testing"
 
 	. "github.com/onsi/gomega"
@@ -146,3 +147,106 @@ func TestExtractMarkerIdAndExpressions(t *testing.T) {
 		})
 	}
 }
+
+func TestExtractMarker(t *testing.T) {
+	type testcase struct {
+		name           string
+		comment        string
+		shouldBeMarker bool
+		expectedID     string
+	}
+
+	testcases := []testcase{
+		{
+			name:           "valid marker - required",
+			comment:        "// +required",
+			shouldBeMarker: true,
+			expectedID:     "required",
+		},
+		{
+			name:           "valid marker - kubebuilder:validation:Required",
+			comment:        "// +kubebuilder:validation:Required",
+			shouldBeMarker: true,
+			expectedID:     "kubebuilder:validation:Required",
+		},
+		{
+			name:           "valid marker - with expressions",
+			comment:        "// +kubebuilder:validation:XValidation:rule=\"something\",message=\"haha\"",
+			shouldBeMarker: true,
+			expectedID:     "kubebuilder:validation:XValidation",
+		},
+		{
+			name:           "valid marker - with parentheses",
+			comment:        "// +k8s:ifEnabled(\"foo\")=+k8s:required",
+			shouldBeMarker: true,
+			expectedID:     "k8s:ifEnabled(\"foo\")",
+		},
+		{
+			name:           "valid marker - with single quotes and parentheses",
+			comment:        "// +k8s:ifEnabled('foo')=+k8s:required",
+			shouldBeMarker: true,
+			expectedID:     "k8s:ifEnabled('foo')",
+		},
+		{
+			name:           "valid marker - with backtickets and parentheses",
+			comment:        "// +k8s:ifEnabled(`foo`)=+k8s:required",
+			shouldBeMarker: true,
+			expectedID:     "k8s:ifEnabled(`foo`)",
+		},
+		{
+			name:           "invalid marker - markdown table border",
+			comment:        "// +-------+-------+-------+",
+			shouldBeMarker: false,
+			expectedID:     "",
+		},
+		{
+			name:           "invalid marker - markdown table border without pipes",
+			comment:        "// +----------",
+			shouldBeMarker: false,
+			expectedID:     "",
+		},
+		{
+			name:           "invalid marker - starts with special characters",
+			comment:        "// +!*@(#&KSDJUF:A",
+			shouldBeMarker: false,
+			expectedID:     "",
+		},
+		{
+			name:           "regular comment - no plus sign",
+			comment:        "// This is a regular comment",
+			shouldBeMarker: false,
+			expectedID:     "",
+		},
+		{
+			name:           "valid marker - complex nested expression",
+			comment:        "// +k8s:someThing(one: \"a\", two: \"b\")=+k8s:required",
+			shouldBeMarker: true,
+			expectedID:     "k8s:someThing(one: \"a\", two: \"b\")",
+		},
+		{
+			name:           "valid marker - complex nested expression with '",
+			comment:        "// +k8s:someThing(one: 'a', two: 'b')=+k8s:required",
+			shouldBeMarker: true,
+			expectedID:     "k8s:someThing(one: 'a', two: 'b')",
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			g := NewWithT(t)
+
+			// Create a mock comment
+			comment := &ast.Comment{
+				Text: tc.comment,
+			}
+
+			marker := extractMarker(comment)
+
+			if tc.shouldBeMarker {
+				g.Expect(marker.Identifier).To(Equal(tc.expectedID), "comment", tc.comment)
+			} else {
+				g.Expect(marker.Identifier).To(BeEmpty(), "comment", tc.comment)
+			}
+		})
+	}
+}