Delegees

Author: bep

go.mod

@@ -22,6 +22,7 @@ require (
 	github.com/bep/overlayfs v0.10.0
 	github.com/bep/simplecobra v0.6.0
 	github.com/bep/tmc v0.5.1
+	github.com/bits-and-blooms/bitset v1.22.0
 	github.com/cespare/xxhash/v2 v2.3.0
 	github.com/clbanning/mxj/v2 v2.7.0
 	github.com/disintegration/gift v1.2.1
@@ -118,7 +119,6 @@ require (
 	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.4 // indirect
 	github.com/aws/aws-sdk-go-v2/service/sts v1.30.3 // indirect
 	github.com/aws/smithy-go v1.22.2 // indirect
-	github.com/bits-and-blooms/bitset v1.22.0 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.6 // indirect
 	github.com/dlclark/regexp2 v1.11.5 // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect

hugolib/content_map.go

@@ -71,7 +71,7 @@ func (r resourceSource) clone() *resourceSource {
 	return &r
 }
 
-func (r *resourceSource) Dim() doctree.Dimensions {
+func (r *resourceSource) Dims() doctree.Dimensions {
 	return r.dims
 }
 
@@ -97,6 +97,10 @@ func (r *resourceSource) GetIdentity() identity.Identity {
 	return r.path
 }
 
+func (p *resourceSource) matchDirectOrInDelegees(doctree.Dimensions) (contentNodeI, doctree.Dimensions) {
+	panic("not implemented")
+}
+
 func (r *resourceSource) ForEeachIdentity(f func(identity.Identity) bool) bool {
 	return f(r.GetIdentity())
 }
@@ -137,6 +141,10 @@ func (n resourceSources) resetBuildState() {
 	}
 }
 
+func (n resourceSources) matchDirectOrInDelegees(doctree.Dimensions) (contentNodeI, doctree.Dimensions) {
+	panic("not implemented")
+}
+
 func (n resourceSources) GetIdentity() identity.Identity {
 	for _, r := range n {
 		if r != nil {

hugolib/content_map_page.go

@@ -17,6 +17,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"iter"
 	"path"
 	"sort"
 	"strconv"
@@ -367,8 +368,9 @@ func (m *pageMap) getPagesInSection(q pageMapQueryPagesInSection) page.Pages {
 		}
 
 		w := &doctree.NodeShiftTreeWalker[contentNodeI]{
-			Tree:   m.treePages,
-			Prefix: prefix,
+			Tree:            m.treePages,
+			Prefix:          prefix,
+			DelegeeFallback: true,
 		}
 
 		w.Handle = func(key string, n contentNodeI, match doctree.DimensionFlag) (bool, error) {
@@ -649,6 +651,7 @@ type contentNodeI interface {
 	identity.ForEeachIdentityProvider
 	Path() string
 	isContentNodeBranch() bool
+	matchDirectOrInDelegees(doctree.Dimensions) (contentNodeI, doctree.Dimensions)
 	buildStateReseter
 	resource.StaleMarker
 }
@@ -672,6 +675,10 @@ func (n contentNodeIs) isContentNodeBranch() bool {
 	return n.one().isContentNodeBranch()
 }
 
+func (p contentNodeIs) matchDirectOrInDelegees(doctree.Dimensions) (contentNodeI, doctree.Dimensions) {
+	panic("not implemented")
+}
+
 func (n contentNodeIs) GetIdentity() identity.Identity {
 	return n.one().GetIdentity()
 }
@@ -705,13 +712,13 @@ type contentNodeShifter struct {
 	numLanguages int
 }
 
-func (s *contentNodeShifter) Delete(n contentNodeI, dimension doctree.Dimensions) (contentNodeI, bool, bool) {
+func (s *contentNodeShifter) Delete(n contentNodeI, dims doctree.Dimensions) (contentNodeI, bool, bool) {
 	switch v := n.(type) {
 	case contentNodeIs:
-		deleted := v[dimension]
+		deleted := v[dims]
 		resource.MarkStale(deleted)
 		wasDeleted := deleted != nil
-		v[dimension] = nil
+		v[dims] = nil
 		isEmpty := true
 		for _, vv := range v {
 			if vv != nil {
@@ -721,10 +728,10 @@ func (s *contentNodeShifter) Delete(n contentNodeI, dimension doctree.Dimensions
 		}
 		return deleted, wasDeleted, isEmpty
 	case resourceSources:
-		deleted := v[dimension]
+		deleted := v[dims]
 		resource.MarkStale(deleted)
 		wasDeleted := deleted != nil
-		v[dimension] = nil
+		v[dims] = nil
 		isEmpty := true
 		for _, vv := range v {
 			if vv != nil {
@@ -734,13 +741,13 @@ func (s *contentNodeShifter) Delete(n contentNodeI, dimension doctree.Dimensions
 		}
 		return deleted, wasDeleted, isEmpty
 	case *resourceSource:
-		if dimension != v.Dim() {
+		if dims != v.Dims() {
 			return nil, false, false
 		}
 		resource.MarkStale(v)
 		return v, true, true
 	case *pageState:
-		if dimension != v.s.dims {
+		if dims != v.s.dims {
 			return nil, false, false
 		}
 		resource.MarkStale(v)
@@ -750,8 +757,25 @@ func (s *contentNodeShifter) Delete(n contentNodeI, dimension doctree.Dimensions
 	}
 }
 
-func (s *contentNodeShifter) Shift(n contentNodeI, dims doctree.Dimensions, exact bool) (contentNodeI, bool, doctree.DimensionFlag) {
-	// How accurate is the match.
+func (s *contentNodeShifter) findDelegee(q doctree.Dimensions, candidates iter.Seq[contentNodeI]) contentNodeI {
+	var (
+		best     contentNodeI = nil
+		bestDims doctree.Dimensions
+	)
+	for n := range candidates {
+		if nn, dims := n.matchDirectOrInDelegees(q); nn != nil {
+			if best == nil || dims.Compare(bestDims) < 0 {
+				best = nn
+				bestDims = dims
+			}
+		}
+	}
+	return best
+}
+
+func (s *contentNodeShifter) Shift(n contentNodeI, dims doctree.Dimensions, exact, delegeeFallback bool) (contentNodeI, bool, doctree.DimensionFlag) {
+	// dims: language, version and role
+	// How accurate is the match. TODO1 revise this.
 	accuracy := doctree.DimensionLanguage
 	switch v := n.(type) {
 	case contentNodeIs:
@@ -762,6 +786,19 @@ func (s *contentNodeShifter) Shift(n contentNodeI, dims doctree.Dimensions, exac
 		if vv != nil {
 			return vv, true, accuracy
 		}
+		if !delegeeFallback {
+			return nil, false, 0
+		}
+		iter := func(yield func(n contentNodeI) bool) {
+			for _, nn := range v {
+				if !yield(nn) {
+					return
+				}
+			}
+		}
+		if vv = s.findDelegee(dims, iter); vv != nil {
+			return vv, true, accuracy
+		}
 		return nil, false, 0
 	case resourceSources:
 		vv := v[dims]
@@ -781,7 +818,7 @@ func (s *contentNodeShifter) Shift(n contentNodeI, dims doctree.Dimensions, exac
 			}
 		}
 	case *resourceSource:
-		if v.Dim() == dims {
+		if v.Dims() == dims {
 			return v, true, doctree.DimensionLanguage // TODO1
 		}
 		if !v.isPage() && !exact {
@@ -843,11 +880,11 @@ func (s *contentNodeShifter) InsertInto(old, new contentNodeI, dimension doctree
 		if !ok {
 			panic(fmt.Sprintf("unknown type %T", new))
 		}
-		if vv.Dim() == newp.Dim() && newp.Dim() == dimension {
+		if vv.Dims() == newp.Dims() && newp.Dims() == dimension {
 			return new, vv, true
 		}
 		rs := make(resourceSources, s.numLanguages)
-		rs[vv.Dim()] = vv
+		rs[vv.Dims()] = vv
 		rs[dimension] = newp
 		return rs, vv, false
 
@@ -889,26 +926,26 @@ func (s *contentNodeShifter) Insert(old, new contentNodeI) (contentNodeI, conten
 		if !ok {
 			panic(fmt.Sprintf("unknown type %T", new))
 		}
-		if vv.Dim() == newp.Dim() {
+		if vv.Dims() == newp.Dims() {
 			if vv != newp {
 				resource.MarkStale(vv)
 			}
 			return new, vv, true
 		}
 		rs := make(resourceSources, s.numLanguages)
-		rs[newp.Dim()] = newp
-		rs[vv.Dim()] = vv
+		rs[newp.Dims()] = newp
+		rs[vv.Dims()] = vv
 		return rs, vv, false
 	case resourceSources:
 		newp, ok := new.(*resourceSource)
 		if !ok {
 			panic(fmt.Sprintf("unknown type %T", new))
 		}
-		oldp := vv[newp.Dim()]
+		oldp := vv[newp.Dims()]
 		if oldp != newp {
 			resource.MarkStale(oldp)
 		}
-		vv[newp.Dim()] = newp
+		vv[newp.Dims()] = newp
 		return vv, oldp, oldp != nil
 	default:
 		panic(fmt.Sprintf("unknown type %T", old))
@@ -1050,7 +1087,7 @@ func (m *pageMap) debugPrint(prefix string, maxLevel int, w io.Writer) {
 
 		resourceWalker.Handle = func(ss string, n contentNodeI, match doctree.DimensionFlag) (bool, error) {
 			if isBranch {
-				ownerKey, _ := pageWalker.Tree.LongestPrefix(ss, true, nil)
+				ownerKey, _ := pageWalker.Tree.LongestPrefix(ss, true, false, nil)
 				if ownerKey != keyPage {
 					// Stop walking downwards, someone else owns this resource.
 					pageWalker.SkipPrefix(ownerKey + "/")
@@ -1500,7 +1537,7 @@ func (sa *sitePagesAssembler) applyAggregates() error {
 
 		rw.Handle = func(resourceKey string, n contentNodeI, match doctree.DimensionFlag) (bool, error) {
 			if isBranch {
-				ownerKey, _ := pw.Tree.LongestPrefix(resourceKey, true, nil)
+				ownerKey, _ := pw.Tree.LongestPrefix(resourceKey, true, false, nil)
 				if ownerKey != keyPage {
 					// Stop walking downwards, someone else owns this resource.
 					rw.SkipPrefix(ownerKey + "/")

hugolib/doctree/dimensions.go

@@ -23,6 +23,30 @@ const (
 // Dimensions is a row in the Hugo build matrix which currently has three values: language, version and role, in that order.
 type Dimensions [3]int
 
+// Compare returns -1 if this dimension is less than the given dimension, 0 if they are equal, and 1 if this dimension is greater than the given dimension.
+// This adds a impicit weighting to the dimensions, where the first dimension is the most important,
+// but this is just used for sorting to get stable output.
+func (d Dimensions) Compare(e Dimensions) int {
+	// note that a and b will never be equal.
+	minusOneOrOne := func(a, b int) int {
+		if a < b {
+			return -1
+		}
+		return 1
+	}
+	if d[0] != e[0] {
+		return minusOneOrOne(d[0], e[0])
+	}
+	if d[1] != e[1] {
+		return minusOneOrOne(d[1], e[1])
+	}
+	if d[2] != e[2] {
+		return minusOneOrOne(d[2], e[2])
+	}
+	// They are equal.
+	return 0
+}
+
 // Language returns the language dimension.
 func (d Dimensions) Language() int {
 	return d[DimensionLanguage.Index()]

hugolib/doctree/dimensions_test.go

@@ -42,3 +42,19 @@ func TestDimensionsIndex(t *testing.T) {
 	c.Assert(DimensionVersion.Index(), qt.Equals, 1)
 	c.Assert(DimensionRole.Index(), qt.Equals, 2)
 }
+
+func TestDimensionsCompare(t *testing.T) {
+	c := qt.New(t)
+
+	c.Assert(Dimensions{1, 2, 3}.Compare(Dimensions{1, 2, 8}), qt.Equals, -1)
+	c.Assert(Dimensions{1, 2, 3}.Compare(Dimensions{1, 2, 3}), qt.Equals, 0)
+	c.Assert(Dimensions{1, 2, 3}.Compare(Dimensions{1, 2, 0}), qt.Equals, 1)
+	c.Assert(Dimensions{1, 2, 3}.Compare(Dimensions{1, 0, 3}), qt.Equals, 1)
+	c.Assert(Dimensions{1, 2, 3}.Compare(Dimensions{0, 3, 2}), qt.Equals, 1)
+	c.Assert(Dimensions{1, 2, 3}.Compare(Dimensions{0, 0, 0}), qt.Equals, 1)
+	c.Assert(Dimensions{0, 0, 0}.Compare(Dimensions{1, 2, 3}), qt.Equals, -1)
+	c.Assert(Dimensions{0, 0, 0}.Compare(Dimensions{0, 0, 0}), qt.Equals, 0)
+	c.Assert(Dimensions{0, 0, 0}.Compare(Dimensions{1, 0, 0}), qt.Equals, -1)
+	c.Assert(Dimensions{0, 0, 0}.Compare(Dimensions{0, 1, 0}), qt.Equals, -1)
+	c.Assert(Dimensions{0, 0, 0}.Compare(Dimensions{0, 0, 1}), qt.Equals, -1)
+}

hugolib/doctree/nodeshiftree_test.go

@@ -52,7 +52,7 @@ func TestTree(t *testing.T) {
 	zeroZero.InsertIntoValuesDimension("/a/b", ab)
 
 	c.Assert(zeroZero.Get("/a"), eq, &testValue{ID: "/a", Lang: 0})
-	s, v := zeroZero.LongestPrefix("/a/b/c", true, nil)
+	s, v := zeroZero.LongestPrefix("/a/b/c", true, false, nil)
 	c.Assert(v, eq, ab)
 	c.Assert(s, eq, "/a/b")
 
@@ -251,7 +251,7 @@ func (s *testShifter) Delete(n *testValue, dimension doctree.Dimensions) (*testV
 	return nil, true, true
 }
 
-func (s *testShifter) Shift(n *testValue, dimension doctree.Dimensions, exact bool) (*testValue, bool, doctree.DimensionFlag) {
+func (s *testShifter) Shift(n *testValue, dimension doctree.Dimensions, exact, matchDelegees bool) (*testValue, bool, doctree.DimensionFlag) {
 	if s.echo {
 		return n, true, doctree.DimensionLanguage
 	}

hugolib/doctree/nodeshifttree.go

@@ -54,7 +54,7 @@ type (
 		// Shift shifts T into the given dimension
 		// and returns the shifted T and a bool indicating if the shift was successful and
 		// how accurate a match T is according to its dimensions.
-		Shift(v T, dimension Dimensions, exact bool) (T, bool, DimensionFlag)
+		Shift(v T, dimension Dimensions, exact, delegeeFallback bool) (T, bool, DimensionFlag)
 	}
 )
 
@@ -226,12 +226,12 @@ func (t *NodeShiftTree[T]) Lock(writable bool) (commit func()) {
 
 // LongestPrefix finds the longest prefix of s that exists in the tree that also matches the predicate (if set).
 // Set exact to true to only match exact in the current dimension (e.g. language).
-func (r *NodeShiftTree[T]) LongestPrefix(s string, exact bool, predicate func(v T) bool) (string, T) {
+func (r *NodeShiftTree[T]) LongestPrefix(s string, exact, delegeeFallback bool, predicate func(v T) bool) (string, T) {
 	for {
 		longestPrefix, v, found := r.tree.LongestPrefix(s)
 
 		if found {
-			if t, ok, _ := r.shift(v.(T), exact); ok && (predicate == nil || predicate(t)) {
+			if t, ok, _ := r.shift(v.(T), exact, delegeeFallback); ok && (predicate == nil || predicate(t)) {
 				return longestPrefix, t
 			}
 		}
@@ -317,6 +317,9 @@ type NodeShiftTreeWalker[T any] struct {
 	// Don't fall back to alternative dimensions (e.g. language).
 	Exact bool
 
+	// TODO1 document this and check vs exact.
+	DelegeeFallback bool
+
 	// Used in development only.
 	Debug bool
 
@@ -408,7 +411,7 @@ func (r *NodeShiftTreeWalker[T]) toT(tree *NodeShiftTree[T], v any) (t T, ok boo
 		t = v.(T)
 		ok = true
 	} else {
-		t, ok, exact = tree.shift(v.(T), r.Exact)
+		t, ok, exact = tree.shift(v.(T), r.Exact, r.DelegeeFallback)
 	}
 	return
 }
@@ -422,10 +425,10 @@ func (t NodeShiftTree[T]) clone() *NodeShiftTree[T] {
 	return &t
 }
 
-func (r *NodeShiftTree[T]) shift(t T, exact bool) (T, bool, DimensionFlag) {
+func (r *NodeShiftTree[T]) shift(t T, exact, delegeeFallback bool) (T, bool, DimensionFlag) {
 	// TODO1 exact.
 	exact = true
-	return r.shifter.Shift(t, r.dims, exact)
+	return r.shifter.Shift(t, r.dims, exact, delegeeFallback)
 }
 
 func (r *NodeShiftTree[T]) get(s string) (T, bool) {
@@ -435,7 +438,7 @@ func (r *NodeShiftTree[T]) get(s string) (T, bool) {
 		var t T
 		return t, false
 	}
-	t, ok, _ := r.shift(v.(T), true)
+	t, ok, _ := r.shift(v.(T), true, false) // TODO1
 	return t, ok
 }