Accept filter instead of exclude mask for ignored fields

fieldpath/set.go

@@ -17,6 +17,7 @@ limitations under the License.
 package fieldpath
 
 import (
+	"fmt"
 	"sort"
 	"strings"
 
@@ -136,6 +137,113 @@ func (s *Set) EnsureNamedFieldsAreMembers(sc *schema.Schema, tr schema.TypeRef)
 	}
 }
 
+// MustPrefixPattern is the same as PrefixPattern except it panics if parts can't be
+// turned into a SetPattern.
+func MustPrefixPattern(parts ...interface{}) *SetPattern {
+	result, err := PrefixPattern(parts...)
+	if err != nil {
+		panic(err)
+	}
+	return result
+}
+
+// PrefixPattern creates a SetPattern that matches all field paths prefixed by the given list of pattern path parts.
+// The pattern parts may be PathPatterns, PathElements, strings (for field names) or ints (for array indices).
+// `MatchAnyPathElement()` may be used as a pattern path part to wildcard match a field path part.
+func PrefixPattern(parts ...interface{}) (*SetPattern, error) {
+	current := MatchAnySet() // match all field patch suffixes
+	for i := len(parts) - 1; i >= 0; i-- {
+		part := parts[i]
+		var pattern PathPattern
+		switch t := part.(type) {
+		case PathPattern:
+			pattern = t
+		case PathElement:
+			pattern = PathPattern{PathElement: t}
+		case string:
+			pattern = PathPattern{PathElement: PathElement{FieldName: &t}}
+		case int:
+			pattern = PathPattern{PathElement: PathElement{Index: &t}}
+		default:
+			return nil, fmt.Errorf("unexpected type %T", t)
+		}
+		current = &SetPattern{
+			Members: []*MemberSetPattern{{
+				Path:  pattern,
+				Child: current,
+			}},
+		}
+	}
+	return current, nil
+}
+
+// MatchAnyPathElement returns a PathPattern that matches any path element.
+func MatchAnyPathElement() PathPattern {
+	return PathPattern{Wildcard: true}
+}
+
+// MatchAnySet returns a SetPattern that matches any set.
+func MatchAnySet() *SetPattern {
+	return &SetPattern{Wildcard: true}
+}
+
+// SetPattern defines a pattern that matches fields in a Set.
+// SetPattern is structured much like a Set but with wildcard support.
+type SetPattern struct {
+	// Wildcard indicates that all members and children are included in the match.
+	// If set, the Members field is ignored.
+	Wildcard bool
+	// Members provides patterns to match the members of a Set.
+	Members []*MemberSetPattern
+}
+
+// MemberSetPattern defines a pattern that matches the members of a Set.
+// MemberSetPattern is structured much like the elements of a SetNodeMap, but
+// with wildcard support.
+type MemberSetPattern struct {
+	// Path provides a pattern to match members of a Set.
+	// If Path is a wildcard, all members of a Set are included in the match.
+	// Otherwise, if any Path is Equal to a member of a Set, that member is
+	// included in the match and the children of that member are matched
+	// against the Child pattern.
+	Path PathPattern
+
+	// Child provides a pattern to use for the children of matched members of a Set.
+	Child *SetPattern
+}
+
+// PathPattern defined a match pattern for a PathElement.
+type PathPattern struct {
+	// Wildcard indicates that all PathElements are matched by this pattern.
+	// If set, PathElement is ignored.
+	Wildcard bool
+
+	// PathElement indicates that a PathElement is matched if it is Equal
+	// to this PathElement.
+	PathElement
+}
+
+// FilterByPattern returns a Set with only the field paths that match the pattern.
+func (s *Set) FilterByPattern(pattern *SetPattern) *Set {
+	if pattern.Wildcard {
+		return s
+	}
+
+	members := PathElementSet{}
+	for _, m := range s.Members.members {
+		for _, pm := range pattern.Members {
+			if pm.Path.Wildcard || pm.Path.PathElement.Equals(m) {
+				members.Insert(m)
+				break
+			}
+		}
+	}
+	return &Set{
+		Members:  members,
+		Children: *s.Children.FilterByPattern(pattern),
+	}
+}
+
 // Size returns the number of members of the set.
 func (s *Set) Size() int {
 	return s.Members.Size() + s.Children.Size()
@@ -476,6 +584,33 @@ func (s *SetNodeMap) EnsureNamedFieldsAreMembers(sc *schema.Schema, tr schema.Ty
 	}
 }
 
+// FilterByPattern returns a SetNodeMap with only the field paths that match the pattern.
+func (s *SetNodeMap) FilterByPattern(pattern *SetPattern) *SetNodeMap {
+	if pattern.Wildcard {
+		return s
+	}
+
+	var out sortedSetNode
+	for _, member := range s.members {
+		for _, c := range pattern.Members {
+			if c.Path.Wildcard || c.Path.PathElement.Equals(member.pathElement) {
+				childSet := member.set.FilterByPattern(c.Child)
+				if childSet.Size() > 0 {
+					out = append(out, setNode{
+						pathElement: member.pathElement,
+						set:         childSet,
+					})
+				}
+				break
+			}
+		}
+	}
+
+	return &SetNodeMap{
+		members: out,
+	}
+}
+
 // Iterate calls f for each PathElement in the set.
 func (s *SetNodeMap) Iterate(f func(PathElement)) {
 	for _, n := range s.members {
@@ -503,3 +638,50 @@ func (s *SetNodeMap) Leaves() *SetNodeMap {
 	}
 	return out
 }
+
+// Filter defines an interface for filtering a set.
+// NewExcludeFilter can be used to create a filter that removes
+// excluded field paths.
+// NewPatternFilter can be used to create a filter that removes all fields except
+// the fields that match a field path pattern. PrefixPattern and MustPrefixPattern
+// can be used to define field path patterns.
+type Filter interface {
+	// Filter returns a filtered copy of the set.
+	Filter(*Set) *Set
+}
+
+// NewExcludeFilter returns a filter that removes field paths in the exclude set.
+func NewExcludeFilter(exclude *Set) Filter {
+	return excludeFilter{exclude}
+}
+
+// NewExcludeFilterMap converts a map of APIVersion to exclude set to a map of APIVersion to exclude filters.
+func NewExcludeFilterMap(resetFields map[APIVersion]*Set) map[APIVersion]Filter {
+	result := make(map[APIVersion]Filter)
+	for k, v := range resetFields {
+		result[k] = excludeFilter{v}
+	}
+	return result
+}
+
+type excludeFilter struct {
+	excludeSet *Set
+}
+
+func (t excludeFilter) Filter(set *Set) *Set {
+	return set.RecursiveDifference(t.excludeSet)
+}
+
+// NewPatternFilter returns a filter that only includes field paths that match the pattern.
+// PrefixPattern and MustPrefixPattern can help create basic SetPatterns.
+func NewPatternFilter(pattern *SetPattern) Filter {
+	return patternFilter{pattern}
+}
+
+type patternFilter struct {
+	pattern *SetPattern
+}
+
+func (pf patternFilter) Filter(set *Set) *Set {
+	return set.FilterByPattern(pf.pattern)
+}

fieldpath/set_test.go

@@ -755,3 +755,96 @@ func TestSetNodeMapIterate(t *testing.T) {
 		}
 	}
 }
+
+func TestFilterByPattern(t *testing.T) {
+	testCases := []struct {
+		name   string
+		input  *Set
+		expect *Set
+	}{
+		{
+			name: "exact match",
+			input: NewSet(
+				MakePathOrDie("spec"),
+				MakePathOrDie("spec", "containers"),
+				MakePathOrDie("spec", "containers", 0, "resources"),
+				MakePathOrDie("spec", "containers", 0, "resources", "limits"),
+				MakePathOrDie("spec", "containers", 0, "resources", "limits", "cpu"),
+				MakePathOrDie("spec", "containers", 0, "resources", "requests"),
+				MakePathOrDie("spec", "containers", 0, "resources", "requests", "cpu"),
+				MakePathOrDie("spec", "containers", 0, "resources", "claims"),
+				MakePathOrDie("spec", "containers", 0, "resources", "claims", 0, "name"),
+				MakePathOrDie("spec", "containers", 0, "resources", "claims", 0, "request"),
+				MakePathOrDie("spec", "containers", 0, "resources", "claims", 1, "name"),
+				MakePathOrDie("spec", "containers", 0, "resources", "claims", 1, "request"),
+				MakePathOrDie("spec", "containers", 1, "resources"),
+				MakePathOrDie("spec", "containers", 1, "resources", "limits"),
+				MakePathOrDie("spec", "containers", 1, "resources", "limits", "cpu"),
+			),
+			expect: NewSet(
+				MakePathOrDie("spec"),
+				MakePathOrDie("spec", "containers"),
+				MakePathOrDie("spec", "containers", 0, "resources"),
+				MakePathOrDie("spec", "containers", 0, "resources", "limits"),
+				MakePathOrDie("spec", "containers", 0, "resources", "limits", "cpu"),
+				MakePathOrDie("spec", "containers", 0, "resources", "requests"),
+				MakePathOrDie("spec", "containers", 0, "resources", "requests", "cpu"),
+				MakePathOrDie("spec", "containers", 0, "resources", "claims"),
+				MakePathOrDie("spec", "containers", 0, "resources", "claims", 0, "name"),
+				MakePathOrDie("spec", "containers", 0, "resources", "claims", 0, "request"),
+				MakePathOrDie("spec", "containers", 0, "resources", "claims", 1, "name"),
+				MakePathOrDie("spec", "containers", 0, "resources", "claims", 1, "request"),
+				MakePathOrDie("spec", "containers", 1, "resources"),
+				MakePathOrDie("spec", "containers", 1, "resources", "limits"),
+				MakePathOrDie("spec", "containers", 1, "resources", "limits", "cpu"),
+			),
+		},
+		{
+			name: "filter status and metadata",
+			input: NewSet(
+				MakePathOrDie("spec"),
+				MakePathOrDie("status"),
+				MakePathOrDie("metadata"),
+			),
+			expect: NewSet(
+				MakePathOrDie("spec"),
+			),
+		},
+		{
+			name: "filter non-container spec fields",
+			input: NewSet(
+				MakePathOrDie("spec"),
+				MakePathOrDie("spec", "volumes"),
+				MakePathOrDie("spec", "hostNetwork"),
+			),
+			expect: NewSet(
+				MakePathOrDie("spec"),
+			),
+		},
+		{
+			name: "filter non-resource container fields",
+			input: NewSet(
+				MakePathOrDie("spec"),
+				MakePathOrDie("spec", "containers"),
+				MakePathOrDie("spec", "containers", 0, "image"),
+				MakePathOrDie("spec", "containers", 0, "workingDir"),
+				MakePathOrDie("spec", "containers", 0, "resources"),
+			),
+			expect: NewSet(
+				MakePathOrDie("spec"),
+				MakePathOrDie("spec", "containers"),
+				MakePathOrDie("spec", "containers", 0, "resources"),
+			),
+		},
+	}
+
+	for _, tc := range testCases {
+		filter := NewPatternFilter(MustPrefixPattern("spec", "containers", MatchAnyPathElement(), "resources"))
+		t.Run(tc.name, func(t *testing.T) {
+			filtered := filter.Filter(tc.input)
+			if !filtered.Equals(tc.expect) {
+				t.Errorf("Expected:\n%v\n\nbut got:\n%v", tc.expect, filtered)
+			}
+		})
+	}
+}

internal/fixture/state.go

@@ -538,8 +538,8 @@ type TestCase struct {
 	// ReportInputOnNoop if we don't want to compare the output and
 	// always return it.
 	ReturnInputOnNoop bool
-	// IgnoredFields containing the set to ignore for every version
-	IgnoredFields map[fieldpath.APIVersion]*fieldpath.Set
+	// IgnoreFilter filters out ignored fields from a fieldpath.Set.
+	IgnoreFilter map[fieldpath.APIVersion]fieldpath.Filter
 }
 
 // Test runs the test-case using the given parser and a dummy converter.
@@ -572,7 +572,7 @@ func (tc TestCase) PreprocessOperations(parser Parser) error {
 func (tc TestCase) BenchWithConverter(parser Parser, converter merge.Converter) error {
 	updaterBuilder := merge.UpdaterBuilder{
 		Converter:         converter,
-		IgnoredFields:     tc.IgnoredFields,
+		IgnoreFilter:      tc.IgnoreFilter,
 		ReturnInputOnNoop: tc.ReturnInputOnNoop,
 	}
 	state := State{
@@ -594,7 +594,7 @@ func (tc TestCase) BenchWithConverter(parser Parser, converter merge.Converter)
 func (tc TestCase) TestWithConverter(parser Parser, converter merge.Converter) error {
 	updaterBuilder := merge.UpdaterBuilder{
 		Converter:         converter,
-		IgnoredFields:     tc.IgnoredFields,
+		IgnoreFilter:      tc.IgnoreFilter,
 		ReturnInputOnNoop: tc.ReturnInputOnNoop,
 	}
 	state := State{