Allow partials to work as decorators

Fixes #13193

Author: bep

cache/dynacache/dynacache.go

@@ -69,7 +69,7 @@ func New(opts Options) *Cache {
 
 	infol := opts.Log.InfoCommand("dynacache")
 
-	evictedIdentities := collections.NewStack[KeyIdentity]()
+	evictedIdentities := collections.NewStackThreadSafe[KeyIdentity]()
 
 	onEvict := func(k, v any) {
 		if !opts.Watching {
@@ -129,7 +129,7 @@ type Cache struct {
 	partitions map[string]PartitionManager
 
 	onEvict           func(k, v any)
-	evictedIdentities *collections.Stack[KeyIdentity]
+	evictedIdentities *collections.StackThreadSafe[KeyIdentity]
 
 	opts  Options
 	infol logg.LevelLogger

common/collections/stack.go

@@ -21,24 +21,24 @@ import (
 	"github.com/gohugoio/hugo/common/hiter"
 )
 
-// Stack is a simple LIFO stack that is safe for concurrent use.
-type Stack[T any] struct {
+// StackThreadSafe is a simple LIFO stack that is safe for concurrent use.
+type StackThreadSafe[T any] struct {
 	items []T
 	zero  T
 	mu    sync.RWMutex
 }
 
-func NewStack[T any]() *Stack[T] {
-	return &Stack[T]{}
+func NewStackThreadSafe[T any]() *StackThreadSafe[T] {
+	return &StackThreadSafe[T]{}
 }
 
-func (s *Stack[T]) Push(item T) {
+func (s *StackThreadSafe[T]) Push(item T) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	s.items = append(s.items, item)
 }
 
-func (s *Stack[T]) Pop() (T, bool) {
+func (s *StackThreadSafe[T]) Pop() (T, bool) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	if len(s.items) == 0 {
@@ -49,7 +49,7 @@ func (s *Stack[T]) Pop() (T, bool) {
 	return item, true
 }
 
-func (s *Stack[T]) Peek() (T, bool) {
+func (s *StackThreadSafe[T]) Peek() (T, bool) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 	if len(s.items) == 0 {
@@ -58,26 +58,26 @@ func (s *Stack[T]) Peek() (T, bool) {
 	return s.items[len(s.items)-1], true
 }
 
-func (s *Stack[T]) Len() int {
+func (s *StackThreadSafe[T]) Len() int {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 	return len(s.items)
 }
 
 // All returns all items in the stack, from bottom to top.
-func (s *Stack[T]) All() iter.Seq2[int, T] {
+func (s *StackThreadSafe[T]) All() iter.Seq2[int, T] {
 	return hiter.Lock2(slices.All(s.items), s.mu.RLock, s.mu.RUnlock)
 }
 
-func (s *Stack[T]) Drain() []T {
+func (s *StackThreadSafe[T]) Drain() []T {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	items := s.items
 	s.items = nil
 	return items
 }
 
-func (s *Stack[T]) DrainMatching(predicate func(T) bool) []T {
+func (s *StackThreadSafe[T]) DrainMatching(predicate func(T) bool) []T {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	var items []T
@@ -89,3 +89,47 @@ func (s *Stack[T]) DrainMatching(predicate func(T) bool) []T {
 	}
 	return items
 }
+
+// Stack is a simple LIFO stack that is not safe for concurrent use.
+type Stack[T any] struct {
+	items []T
+	zero  T
+}
+
+func NewStack[T any]() *Stack[T] {
+	return &Stack[T]{}
+}
+
+func (s *Stack[T]) Push(item T) {
+	s.items = append(s.items, item)
+}
+
+func (s *Stack[T]) Pop() (T, bool) {
+	if len(s.items) == 0 {
+		return s.zero, false
+	}
+	item := s.items[len(s.items)-1]
+	s.items = s.items[:len(s.items)-1]
+	return item, true
+}
+
+func (s *Stack[T]) Peek() (T, bool) {
+	if len(s.items) == 0 {
+		return s.zero, false
+	}
+	return s.items[len(s.items)-1], true
+}
+
+func (s *Stack[T]) Len() int {
+	return len(s.items)
+}
+
+func (s *Stack[T]) All() iter.Seq2[int, T] {
+	return slices.All(s.items)
+}
+
+func (s *Stack[T]) Drain() []T {
+	items := s.items
+	s.items = nil
+	return items
+}

common/collections/stack_test.go

@@ -10,7 +10,7 @@ func TestNewStack(t *testing.T) {
 	t.Parallel()
 	c := qt.New(t)
 
-	s := NewStack[int]()
+	s := NewStackThreadSafe[int]()
 
 	c.Assert(s, qt.IsNotNil)
 }
@@ -19,7 +19,7 @@ func TestStackBasic(t *testing.T) {
 	t.Parallel()
 	c := qt.New(t)
 
-	s := NewStack[int]()
+	s := NewStackThreadSafe[int]()
 
 	c.Assert(s.Len(), qt.Equals, 0)
 
@@ -50,7 +50,7 @@ func TestStackDrain(t *testing.T) {
 	t.Parallel()
 	c := qt.New(t)
 
-	s := NewStack[string]()
+	s := NewStackThreadSafe[string]()
 	s.Push("a")
 	s.Push("b")
 
@@ -64,7 +64,7 @@ func TestStackDrainMatching(t *testing.T) {
 	t.Parallel()
 	c := qt.New(t)
 
-	s := NewStack[int]()
+	s := NewStackThreadSafe[int]()
 	s.Push(1)
 	s.Push(2)
 	s.Push(3)

common/maps/map.go

@@ -73,6 +73,18 @@ func (m *Map[K, T]) Set(key K, value T) {
 	m.mu.Unlock()
 }
 
+// Delete deletes the given key from the map.
+// It returns true if the key was found and deleted, false otherwise.
+func (m *Map[K, T]) Delete(key K) bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if _, found := m.m[key]; found {
+		delete(m.m, key)
+		return true
+	}
+	return false
+}
+
 // WithWriteLock executes the given function with a write lock on the map.
 func (m *Map[K, T]) WithWriteLock(f func(m map[K]T) error) error {
 	m.mu.Lock()

hugolib/alias.go

@@ -29,7 +29,6 @@ import (
 	"github.com/gohugoio/hugo/output"
 	"github.com/gohugoio/hugo/publisher"
 	"github.com/gohugoio/hugo/resources/page"
-	"github.com/gohugoio/hugo/tpl"
 	"github.com/gohugoio/hugo/tpl/tplimpl"
 )
 
@@ -76,7 +75,7 @@ func (a aliasHandler) renderAlias(permalink string, p page.Page, matrix sitesmat
 		p,
 	}
 
-	ctx := tpl.Context.Page.Set(context.Background(), p)
+	ctx := a.ts.PrepareTopLevelRenderCtx(context.Background(), p)
 
 	buffer := new(bytes.Buffer)
 	err := a.ts.ExecuteWithContext(ctx, t, buffer, data)

hugolib/doctree/support.go

@@ -224,7 +224,7 @@ type WalkContext[T any] struct {
 	events          []*Event[T]
 
 	hooksPostInit sync.Once
-	hooksPost     *collections.Stack[func() error]
+	hooksPost     *collections.StackThreadSafe[func() error]
 }
 
 type eventHandlers[T any] map[string][]func(*Event[T])
@@ -261,9 +261,9 @@ func (ctx *WalkContext[T]) HandleEvents() error {
 	return nil
 }
 
-func (ctx *WalkContext[T]) HooksPost() *collections.Stack[func() error] {
+func (ctx *WalkContext[T]) HooksPost() *collections.StackThreadSafe[func() error] {
 	ctx.hooksPostInit.Do(func() {
-		ctx.hooksPost = collections.NewStack[func() error]()
+		ctx.hooksPost = collections.NewStackThreadSafe[func() error]()
 	})
 	return ctx.hooksPost
 }

hugolib/integrationtest_builder.go

@@ -19,6 +19,7 @@ import (
 	"testing"
 
 	"github.com/bep/logg"
+	"github.com/yuin/goldmark/util"
 
 	qt "github.com/frankban/quicktest"
 	"github.com/fsnotify/fsnotify"
@@ -419,7 +420,7 @@ func (s *IntegrationTestBuilder) AssertFileContent(filename string, matches ...s
 	content := strings.TrimSpace(s.FileContent(filename))
 
 	for _, m := range matches {
-		cm := qt.Commentf("File: %s Expect: %s Got: %s", filename, m, content)
+		cm := qt.Commentf("File: %s Expect:\n%s Got:\n%s\nWith Space Visuals:\n%s", filename, m, content, util.VisualizeSpaces([]byte(content)))
 		lines := strings.SplitSeq(m, "\n")
 		for match := range lines {
 			match = strings.TrimSpace(match)

hugolib/site.go

@@ -1610,7 +1610,7 @@ func (s *Site) renderAndWritePage(statCounter *uint64, targetPath string, p *pag
 	of := p.outputFormat()
 	p.incrRenderState()
 
-	ctx := tpl.Context.Page.Set(context.Background(), p)
+	ctx := s.TemplateStore.PrepareTopLevelRenderCtx(context.Background(), p)
 	ctx = tpl.Context.DependencyManagerScopedProvider.Set(ctx, p)
 
 	if err := s.renderForTemplate(ctx, p.Kind(), of.Name, d, renderBuffer, templ); err != nil {

tpl/partials/partials.go

@@ -145,6 +145,15 @@ func (ns *Namespace) lookup(name string) (*tplimpl.TemplInfo, error) {
 // include is a helper function that lookups and executes the named partial.
 // Returns the final template name and the rendered output.
 func (ns *Namespace) doInclude(ctx context.Context, key string, templ *tplimpl.TemplInfo, dataList ...any) includeResult {
+	if templ.ParseInfo.HasPartialInner {
+		stack := tpl.Context.PartialDecoratorIDStack.Get(ctx)
+		if stack != nil {
+			if id, ok := stack.Peek(); ok {
+				// Signal that inner exists.
+				id.Bool = true
+			}
+		}
+	}
 	var data any
 	if len(dataList) > 0 {
 		data = dataList[0]

tpl/template.go

@@ -23,6 +23,7 @@ import (
 
 	"github.com/bep/helpers/contexthelpers"
 	bp "github.com/gohugoio/hugo/bufferpool"
+	"github.com/gohugoio/hugo/common/collections"
 
 	"github.com/gohugoio/hugo/identity"
 	"github.com/gohugoio/hugo/langs"
@@ -53,6 +54,7 @@ const (
 	contextKeyPage
 	contextKeyIsInGoldmark
 	cntextKeyCurrentTemplateInfo
+	contextKeyPartialDecoratorIDStack
 )
 
 // Context manages values passed in the context to templates.
@@ -63,12 +65,14 @@ var Context = struct {
 	Page                               contexthelpers.ContextDispatcher[page]
 	IsInGoldmark                       contexthelpers.ContextDispatcher[bool]
 	CurrentTemplate                    contexthelpers.ContextDispatcher[*CurrentTemplateInfo]
+	PartialDecoratorIDStack            contexthelpers.ContextDispatcher[*collections.Stack[*StringBool]]
 }{
 	DependencyManagerScopedProvider: contexthelpers.NewContextDispatcher[identity.DependencyManagerScopedProvider](contextKeyDependencyManagerScopedProvider),
 	DependencyScope:                 contexthelpers.NewContextDispatcher[int](contextKeyDependencyScope),
 	Page:                            contexthelpers.NewContextDispatcher[page](contextKeyPage),
 	IsInGoldmark:                    contexthelpers.NewContextDispatcher[bool](contextKeyIsInGoldmark),
 	CurrentTemplate:                 contexthelpers.NewContextDispatcher[*CurrentTemplateInfo](cntextKeyCurrentTemplateInfo),
+	PartialDecoratorIDStack:         contexthelpers.NewContextDispatcher[*collections.Stack[*StringBool]](contextKeyPartialDecoratorIDStack),
 }
 
 func init() {
@@ -81,6 +85,12 @@ func init() {
 	}
 }
 
+// StringBool is a helper struct to hold a string and a bool value.
+type StringBool struct {
+	Str  string
+	Bool bool
+}
+
 type page interface {
 	IsNode() bool
 }