internal: add PathNode.HasPrefix() and use it instead of string-based HasPrefix (#4387)

## Why
I want more code to use *PathNode instead of strings and this change
facilitates that. We also will replace HasPrefix with MatchesPattern and
this changes prepares for that.

## Tests
Existing tests, new unit tests.

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: denik

bundle/deployplan/plan.go

@@ -121,8 +121,17 @@ func (c *Changes) HasChange(fieldPath string) bool {
 		return false
 	}
 
+	fieldPathNode, err := structpath.Parse(fieldPath)
+	if err != nil {
+		return false
+	}
+
 	for field := range *c {
-		if structpath.HasPrefix(field, fieldPath) {
+		fieldNode, err := structpath.Parse(field)
+		if err != nil {
+			continue
+		}
+		if fieldNode.HasPrefix(fieldPathNode) {
 			return true
 		}
 	}

bundle/direct/bundle_plan.go

@@ -383,7 +383,7 @@ func addPerFieldActions(ctx context.Context, adapter *dresources.Adapter, change
 			// Empty struct in config should not cause drift when remote has values
 			ch.Action = deployplan.Skip
 			ch.Reason = deployplan.ReasonEmptyStruct
-		} else if action := shouldIgnore(cfg, pathString); action != deployplan.Undefined {
+		} else if action := shouldIgnore(cfg, path); action != deployplan.Undefined {
 			ch.Action = action
 			ch.Reason = deployplan.ReasonBuiltinRule
 		} else if ch.New == nil && ch.Old == nil && ch.Remote != nil && path.IsDotString() {
@@ -393,7 +393,7 @@ func addPerFieldActions(ctx context.Context, adapter *dresources.Adapter, change
 			// Note, we only consider struct fields here. Adding/removing elements to/from maps and slices should trigger updates.
 			ch.Action = deployplan.Skip
 			ch.Reason = deployplan.ReasonServerSideDefault
-		} else if action := shouldUpdateOrRecreate(cfg, pathString); action != deployplan.Undefined {
+		} else if action := shouldUpdateOrRecreate(cfg, path); action != deployplan.Undefined {
 			ch.Action = action
 			ch.Reason = deployplan.ReasonBuiltinRule
 		} else {
@@ -419,29 +419,29 @@ func addPerFieldActions(ctx context.Context, adapter *dresources.Adapter, change
 	return nil
 }
 
-func shouldIgnore(cfg *dresources.ResourceLifecycleConfig, pathString string) deployplan.ActionType {
+func shouldIgnore(cfg *dresources.ResourceLifecycleConfig, path *structpath.PathNode) deployplan.ActionType {
 	if cfg == nil {
 		return deployplan.Undefined
 	}
 	for _, p := range cfg.IgnoreRemoteChanges {
-		if structpath.HasPrefix(pathString, p.String()) {
+		if path.HasPrefix(p) {
 			return deployplan.Skip
 		}
 	}
 	return deployplan.Undefined
 }
 
-func shouldUpdateOrRecreate(cfg *dresources.ResourceLifecycleConfig, pathString string) deployplan.ActionType {
+func shouldUpdateOrRecreate(cfg *dresources.ResourceLifecycleConfig, path *structpath.PathNode) deployplan.ActionType {
 	if cfg == nil {
 		return deployplan.Undefined
 	}
 	for _, p := range cfg.RecreateOnChanges {
-		if structpath.HasPrefix(pathString, p.String()) {
+		if path.HasPrefix(p) {
 			return deployplan.Recreate
 		}
 	}
 	for _, p := range cfg.UpdateIDOnChanges {
-		if structpath.HasPrefix(pathString, p.String()) {
+		if path.HasPrefix(p) {
 			return deployplan.UpdateWithID
 		}
 	}

libs/structs/structpath/path.go

@@ -669,40 +669,64 @@ func (p *PathNode) Prefix(n int) *PathNode {
 	return current
 }
 
-// HasPrefix tests whether the path string s begins with prefix.
-// Unlike strings.HasPrefix, this function is path-aware and correctly handles
-// path component boundaries. For example:
-//   - HasPrefix("a.b", "a") returns true (matches field "a")
-//   - HasPrefix("aa", "a") returns false (field "aa" is different from "a")
-//   - HasPrefix("a[0]", "a") returns true (matches field "a")
-//   - HasPrefix("config.name", "config") returns true
-func HasPrefix(s, prefix string) bool {
-	// Handle edge cases
-	if prefix == "" {
+// HasPrefix tests whether the path begins with the given prefix PathNode.
+// Returns true if all components of prefix match the first components of this path.
+// A nil prefix (root) always returns true.
+//
+// Examples:
+//   - "a.b".HasPrefix("a") returns true
+//   - "a.b".HasPrefix("a.b.c") returns false (prefix is longer)
+//   - "items[0].name".HasPrefix("items[0]") returns true
+//   - "items[0].name".HasPrefix("items[1]") returns false (different index)
+func (p *PathNode) HasPrefix(prefix *PathNode) bool {
+	// Nil prefix (root) is always a prefix
+	if prefix.IsRoot() {
 		return true
 	}
-	if s == "" {
+
+	// Nil path (root) can only have nil prefix
+	if p.IsRoot() {
 		return false
 	}
-	if s == prefix {
-		return true
-	}
 
-	// Check if s starts with prefix using string comparison
-	if !strings.HasPrefix(s, prefix) {
+	// Get lengths
+	pLen := p.Len()
+	prefixLen := prefix.Len()
+
+	// Prefix cannot be longer than the path
+	if prefixLen > pLen {
 		return false
 	}
 
-	// Ensure the match is at a path boundary
-	// The character after the prefix must be a path separator: '.', '[', or end of string
-	if len(s) > len(prefix) {
-		nextChar := s[len(prefix)]
-		return nextChar == '.' || nextChar == '['
+	// Get to the position in p that corresponds to the last node of prefix
+	pAtPrefixLen := p.Prefix(prefixLen)
+
+	// Walk both paths backwards and compare each node
+	currentP := pAtPrefixLen
+	currentPrefix := prefix
+
+	for currentPrefix != nil {
+		if !nodesEqual(currentP, currentPrefix) {
+			return false
+		}
+		currentP = currentP.prev
+		currentPrefix = currentPrefix.prev
 	}
 
 	return true
 }
 
+// nodesEqual compares two PathNodes for equality (without comparing prev pointers).
+func nodesEqual(a, b *PathNode) bool {
+	if a == nil && b == nil {
+		return true
+	}
+	if a == nil || b == nil {
+		return false
+	}
+	return a.key == b.key && a.index == b.index && a.value == b.value
+}
+
 // MarshalYAML implements yaml.Marshaler for PathNode.
 func (p *PathNode) MarshalYAML() (any, error) {
 	return p.String(), nil

libs/structs/structpath/path_test.go

@@ -744,12 +744,50 @@ func TestHasPrefix(t *testing.T) {
 			prefix:   "a[*]",
 			expected: false,
 		},
+
+		// Exact component matching - array indices, bracket keys, and key-value notation
+		{
+			name:     "prefix longer than path",
+			s:        "a.b",
+			prefix:   "a.b.c",
+			expected: false,
+		},
+		{
+			name:     "different array indices",
+			s:        "items[0].name",
+			prefix:   "items[1]",
+			expected: false,
+		},
+		{
+			name:     "different bracket keys",
+			s:        "config['spark.conf']",
+			prefix:   "config['other.conf']",
+			expected: false,
+		},
+		{
+			name:     "key-value in prefix",
+			s:        "tasks[task_key='my_task'].notebook_task.source",
+			prefix:   "tasks[task_key='my_task']",
+			expected: true,
+		},
+		{
+			name:     "different key-value values",
+			s:        "tasks[task_key='my_task']",
+			prefix:   "tasks[task_key='other_task']",
+			expected: false,
+		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := HasPrefix(tt.s, tt.prefix)
-			assert.Equal(t, tt.expected, result, "HasPrefix(%q, %q)", tt.s, tt.prefix)
+			path, err := Parse(tt.s)
+			require.NoError(t, err)
+
+			prefix, err := Parse(tt.prefix)
+			require.NoError(t, err)
+
+			result := path.HasPrefix(prefix)
+			assert.Equal(t, tt.expected, result, "path.HasPrefix(prefix) where path=%q, prefix=%q", tt.s, tt.prefix)
 		})
 	}
 }