Add range matchers for site matrix vector store filtering

Fixes #14359

Author: bep

common/predicate/predicate.go

@@ -153,8 +153,32 @@ func (p PR[T]) FilterCopy(s []T) []T {
 	return result
 }
 
+const (
+	rangeOpNone = iota
+	rangeOpLT
+	rangeOpLTE
+	rangeOpGT
+	rangeOpGTE
+)
+
+func cutRangeOp(s string) (op int, rest string) {
+	switch {
+	case strings.HasPrefix(s, ">= "):
+		return rangeOpGTE, s[3:]
+	case strings.HasPrefix(s, "<= "):
+		return rangeOpLTE, s[3:]
+	case strings.HasPrefix(s, "> "):
+		return rangeOpGT, s[2:]
+	case strings.HasPrefix(s, "< "):
+		return rangeOpLT, s[2:]
+	default:
+		return rangeOpNone, s
+	}
+}
+
 // NewStringPredicateFromGlobs creates a string predicate from the given glob patterns.
 // A glob pattern starting with "!" is a negation pattern which will be ANDed with the rest.
+// TODO1 consolidate with the one below.
 func NewStringPredicateFromGlobs(patterns []string, getGlob func(pattern string) (glob.Glob, error)) (P[string], error) {
 	var p PR[string]
 	for _, pattern := range patterns {
@@ -187,6 +211,77 @@ func NewStringPredicateFromGlobs(patterns []string, getGlob func(pattern string)
 	return p.BoolFunc(), nil
 }
 
+// NewIndexStringPredicateFromGlobsAndRanges creates a string predicate from the given glob patterns.
+// A glob pattern starting with "!" is a negation pattern which will be ANDed with the rest.
+func NewIndexStringPredicateFromGlobsAndRanges(patterns []string, getIndex func(s string) int, getGlob func(pattern string) (glob.Glob, error)) (P[IndexString], error) {
+	var p PR[IndexString]
+	for _, pattern := range patterns {
+		pattern = strings.TrimSpace(pattern)
+		if pattern == "" {
+			continue
+		}
+		negate := strings.HasPrefix(pattern, hglob.NegationPrefix)
+		if negate {
+			pattern = pattern[2:]
+			g, err := getGlob(pattern)
+			if err != nil {
+				return nil, err
+			}
+			p = p.And(func(s IndexString) Match {
+				return BoolMatch(!g.Match(s.String))
+			})
+		} else {
+			// This can be eiter a glob or a value prefixed with one of >, >=, < or <=.
+			o, v := cutRangeOp(pattern)
+			if o != rangeOpNone {
+				i := getIndex(v)
+				if i == -1 {
+					// No match possible.
+					p = p.And(func(s IndexString) Match {
+						return BoolMatch(false)
+					})
+					continue
+				}
+				switch o {
+				// The greater values starts at the top with index 0.
+				case rangeOpGT:
+					p = p.And(func(s IndexString) Match {
+						return BoolMatch(s.Index < i)
+					})
+				case rangeOpGTE:
+					p = p.And(func(s IndexString) Match {
+						return BoolMatch(s.Index <= i)
+					})
+				case rangeOpLT:
+					p = p.And(func(s IndexString) Match {
+						return BoolMatch(s.Index > i)
+					})
+				case rangeOpLTE:
+					p = p.And(func(s IndexString) Match {
+						return BoolMatch(s.Index >= i)
+					})
+				}
+			} else {
+				g, err := getGlob(pattern)
+				if err != nil {
+					return nil, err
+				}
+				p = p.Or(func(s IndexString) Match {
+					return BoolMatch(g.Match(s.String))
+				})
+			}
+
+		}
+	}
+
+	return p.BoolFunc(), nil
+}
+
+type IndexString struct {
+	Index  int
+	String string
+}
+
 type IndexMatcher interface {
-	IndexMatch(match P[string]) (iter.Seq[int], error)
+	IndexMatch(match P[IndexString]) (iter.Seq[int], error)
 }

common/predicate/predicate_test.go

@@ -132,7 +132,7 @@ func TestNewStringPredicateFromGlobs(t *testing.T) {
 	}
 
 	n := func(patterns ...string) predicate.P[string] {
-		p, err := predicate.NewStringPredicateFromGlobs(patterns, getGlob)
+		p, err := predicate.NewIndexStringPredicateFromGlobsAndRanges(patterns, getGlob)
 		c.Assert(err, qt.IsNil)
 		return p
 	}

hugolib/roles/roles.go

@@ -102,14 +102,14 @@ func (r RolesInternal) ResolveIndex(name string) int {
 			return i
 		}
 	}
-	panic(fmt.Sprintf("no role found for name %q", name))
+	return -1
 }
 
 // IndexMatch returns an iterator for the roles that match the filter.
-func (r RolesInternal) IndexMatch(match predicate.P[string]) (iter.Seq[int], error) {
+func (r RolesInternal) IndexMatch(match predicate.P[predicate.IndexString]) (iter.Seq[int], error) {
 	return func(yield func(i int) bool) {
 		for i, role := range r.Sorted {
-			if match(role.Name) {
+			if match(predicate.IndexString{Index: i, String: role.Name}) {
 				if !yield(i) {
 					return
 				}

hugolib/sitesmatrix/sitematrix_integration_test.go

@@ -1430,3 +1430,112 @@ All.
 	b = hugolib.Test(t, files)
 	b.AssertFileContent("public/guest/en/index.html", "url=https://example.org/guest/\"")
 }
+
+func TestSitesMatrixRangeMatchers(t *testing.T) {
+	t.Parallel()
+	files := `TestSitesMatrixRangeMatchers
+-- hugo.toml --
+baseURL = "https://example.org/"
+defaultContentVersion = "v4.0.0"
+defaultContentVersionInSubDir = true
+disableKinds = ["taxonomy", "term", "rss", "sitemap"]
+
+[languages]
+[languages.en]
+weight = 1
+
+[versions]
+[versions."v1.0.0"]
+[versions."v2.0.0"]
+[versions."v2.1.0"]
+[versions."v3.0.0"]
+[versions."v4.0.0"]
+
+-- content/_index.md --
+---
+title: "Home"
+sites:
+  matrix:
+    versions: ["**"]
+---
+-- content/p1.md --
+---
+title: "P1 from v2.0.0"
+sites:
+  matrix:
+    versions: [">= v2.0.0"]
+---
+Content for v2.0.0 and later.
+-- content/p2.md --
+---
+title: "P2 between v2 and v3"
+sites:
+  matrix:
+    versions: [">= v2.0.0", "<= v3.0.0"]
+---
+Content between v2.0.0 and v3.0.0 (inclusive).
+-- content/p3.md --
+---
+title: "P3 before v3"
+sites:
+  matrix:
+    versions: ["< v3.0.0"]
+---
+Content before v3.0.0.
+-- content/p4.md --
+---
+title: "P4 after v2"
+sites:
+  matrix:
+    versions: ["> v2.0.0"]
+---
+Content after v2.0.0 (exclusive).
+-- content/p5.md --
+---
+title: "P5 range with negation"
+sites:
+  matrix:
+    versions: [">= v2.0.0", "! v2.1.0", "<= v4.0.0"]
+---
+Content from v2.0.0 to v4.0.0 but not v2.1.0.
+-- layouts/all.html --
+Title: {{ .Title }}|
+`
+
+	b := hugolib.Test(t, files)
+
+	// P1: >= v2.0.0 should be in v2.0.0, v2.1.0, v3.0.0, v4.0.0
+	b.AssertFileContent("public/v2.0.0/p1/index.html", "Title: P1 from v2.0.0|")
+	b.AssertFileContent("public/v2.1.0/p1/index.html", "Title: P1 from v2.0.0|")
+	b.AssertFileContent("public/v3.0.0/p1/index.html", "Title: P1 from v2.0.0|")
+	b.AssertFileContent("public/v4.0.0/p1/index.html", "Title: P1 from v2.0.0|")
+	b.AssertFileExists("public/v1.0.0/p1/index.html", false)
+
+	// P2: >= v2.0.0 AND <= v3.0.0 should be in v2.0.0, v2.1.0, v3.0.0
+	b.AssertFileContent("public/v2.0.0/p2/index.html", "Title: P2 between v2 and v3|")
+	b.AssertFileContent("public/v2.1.0/p2/index.html", "Title: P2 between v2 and v3|")
+	b.AssertFileContent("public/v3.0.0/p2/index.html", "Title: P2 between v2 and v3|")
+	b.AssertFileExists("public/v1.0.0/p2/index.html", false)
+	b.AssertFileExists("public/v4.0.0/p2/index.html", false)
+
+	// P3: < v3.0.0 should be in v1.0.0, v2.0.0, v2.1.0
+	b.AssertFileContent("public/v1.0.0/p3/index.html", "Title: P3 before v3|")
+	b.AssertFileContent("public/v2.0.0/p3/index.html", "Title: P3 before v3|")
+	b.AssertFileContent("public/v2.1.0/p3/index.html", "Title: P3 before v3|")
+	b.AssertFileExists("public/v3.0.0/p3/index.html", false)
+	b.AssertFileExists("public/v4.0.0/p3/index.html", false)
+
+	// P4: > v2.0.0 should be in v2.1.0, v3.0.0, v4.0.0
+	b.AssertFileContent("public/v2.1.0/p4/index.html", "Title: P4 after v2|")
+	b.AssertFileContent("public/v3.0.0/p4/index.html", "Title: P4 after v2|")
+	b.AssertFileContent("public/v4.0.0/p4/index.html", "Title: P4 after v2|")
+	b.AssertFileExists("public/v1.0.0/p4/index.html", false)
+	b.AssertFileExists("public/v2.0.0/p4/index.html", false)
+
+	// P5: >= v2.0.0 AND ! v2.1.0 AND <= v4.0.0 should be in v2.0.0, v3.0.0, v4.0.0
+	b.AssertFileContent("public/v2.0.0/p5/index.html", "Title: P5 range with negation|")
+	b.AssertFileContent("public/v3.0.0/p5/index.html", "Title: P5 range with negation|")
+	b.AssertFileContent("public/v4.0.0/p5/index.html", "Title: P5 range with negation|")
+	b.AssertFileExists("public/v1.0.0/p5/index.html", false)
+	b.AssertFileExists("public/v2.1.0/p5/index.html", false) // Excluded by negation
+}

hugolib/sitesmatrix/vectorstores.go

@@ -760,22 +760,19 @@ func (b *IntSetsBuilder) WithConfig(cfg IntSetsConfig) *IntSetsBuilder {
 			return result, nil
 		}
 
-		// Dot separated globs.
-		filter, err := predicate.NewStringPredicateFromGlobs(values, hglob.GetGlobDot)
+		filter, err := predicate.NewIndexStringPredicateFromGlobsAndRanges(values, matcher.ResolveIndex, hglob.GetGlobDot)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create filter for %s: %w", what, err)
 		}
-		for _, pattern := range values {
-			iter, err := matcher.IndexMatch(filter)
-			if err != nil {
-				return nil, fmt.Errorf("failed to match %s %q: %w", what, pattern, err)
-			}
-			for i := range iter {
-				if result == nil {
-					result = hmaps.NewOrderedIntSet()
-				}
-				result.Set(i)
+		iter, err := matcher.IndexMatch(filter)
+		if err != nil {
+			return nil, fmt.Errorf("failed to match %s %q: %w", what, values, err)
+		}
+		for i := range iter {
+			if result == nil {
+				result = hmaps.NewOrderedIntSet()
 			}
+			result.Set(i)
 		}
 
 		return result, nil
@@ -968,10 +965,10 @@ func (m *testDimension) ForEachIndex() iter.Seq[int] {
 	}
 }
 
-func (m *testDimension) IndexMatch(match predicate.P[string]) (iter.Seq[int], error) {
+func (m *testDimension) IndexMatch(match predicate.P[predicate.IndexString]) (iter.Seq[int], error) {
 	return func(yield func(i int) bool) {
 		for i, n := range m.names {
-			if match(n) {
+			if match(predicate.IndexString{Index: i, String: n}) {
 				if !yield(i) {
 					return
 				}

hugolib/versions/versions.go

@@ -104,14 +104,14 @@ func (r VersionsInternal) ResolveIndex(name string) int {
 			return i
 		}
 	}
-	panic(fmt.Sprintf("no version found for name %q", name))
+	return -1
 }
 
 // IndexMatch returns an iterator for the versions that match the filter.
-func (r VersionsInternal) IndexMatch(match predicate.P[string]) (iter.Seq[int], error) {
+func (r VersionsInternal) IndexMatch(match predicate.P[predicate.IndexString]) (iter.Seq[int], error) {
 	return func(yield func(i int) bool) {
 		for i, version := range r.Sorted {
-			if match(version.Name) {
+			if match(predicate.IndexString{Index: i, String: version.Name}) {
 				if !yield(i) {
 					return
 				}

langs/config.go

@@ -89,18 +89,18 @@ func (ls LanguagesInternal) ResolveIndex(name string) int {
 			return i
 		}
 	}
-	panic(fmt.Sprintf("no language found for name %q", name))
+	return -1
 }
 
 func (ls LanguagesInternal) Len() int {
 	return len(ls.Sorted)
 }
 
 // IndexMatch returns an iterator for the roles that match the filter.
-func (ls LanguagesInternal) IndexMatch(match predicate.P[string]) (iter.Seq[int], error) {
+func (ls LanguagesInternal) IndexMatch(match predicate.P[predicate.IndexString]) (iter.Seq[int], error) {
 	return func(yield func(i int) bool) {
 		for i, l := range ls.Sorted {
-			if match(l.Name) {
+			if match(predicate.IndexString{Index: i, String: l.Name}) {
 				if !yield(i) {
 					return
 				}