diff --git a/extension.go b/extension.go
index e022efe..f85e08f 100644
--- a/extension.go
+++ b/extension.go
@@ -122,6 +122,7 @@ func (e *CoreExtension) GetFunctions() map[string]FunctionFunc {
"json_encode": e.functionJsonEncode,
"length": e.functionLength,
"merge": e.functionMerge,
+ "parent": e.functionParent,
}
}
@@ -2211,6 +2212,71 @@ func (e *CoreExtension) functionMerge(args ...interface{}) (interface{}, error)
return nil, fmt.Errorf("cannot merge %T, expected array or map", base)
}
+// functionParent implements the parent() function used in template inheritance
+// It renders the content of the parent block when called within a child block
+func (e *CoreExtension) functionParent(args ...interface{}) (interface{}, error) {
+ // This is a special function that requires access to the RenderContext
+ // We return a function that will be called by the RenderContext
+ return func(ctx *RenderContext) (interface{}, error) {
+ if ctx == nil {
+ return nil, errors.New("parent() function can only be used within a block")
+ }
+
+ if ctx.currentBlock == nil {
+ return nil, errors.New("parent() function can only be used within a block")
+ }
+
+ // Get the name of the current block
+ blockName := ctx.currentBlock.name
+
+ // Debug logging
+ LogDebug("parent() call for block '%s'", blockName)
+ LogDebug("inParentCall=%v, currentBlock=%p", ctx.inParentCall, ctx.currentBlock)
+ LogDebug("Blocks in context: %v", getMapKeys(ctx.blocks))
+ LogDebug("Parent blocks in context: %v", getMapKeys(ctx.parentBlocks))
+
+ // Check for parent content in the parentBlocks map
+ parentContent, ok := ctx.parentBlocks[blockName]
+ if !ok || len(parentContent) == 0 {
+ return "", fmt.Errorf("no parent block content found for block '%s'", blockName)
+ }
+
+ // For the simplest possible solution, render the parent content directly
+ // This is the most direct way to avoid recursion issues
+ var result bytes.Buffer
+
+ // Create a clean context without parent() function to prevent recursion
+ cleanCtx := NewRenderContext(ctx.env, ctx.context, ctx.engine)
+ defer cleanCtx.Release()
+
+ // Copy all blocks and variables
+ for name, content := range ctx.blocks {
+ cleanCtx.blocks[name] = content
+ }
+
+ // The key here is to NOT set currentBlock - this breaks the recursion chain
+ cleanCtx.currentBlock = nil
+
+ // Render each node with the clean context
+ for _, node := range parentContent {
+ if err := node.Render(&result, cleanCtx); err != nil {
+ return nil, err
+ }
+ }
+
+ return result.String(), nil
+ }, nil
+}
+
+// Helper functions for debugging
+func getMapKeys(m map[string][]Node) []string {
+ keys := make([]string, 0, len(m))
+ for k := range m {
+ keys = append(keys, k)
+ }
+ return keys
+}
+
func escapeHTML(s string) string {
return html.EscapeString(s)
}
diff --git a/node.go b/node.go
index 36ee929..0ba7f95 100644
--- a/node.go
+++ b/node.go
@@ -617,7 +617,21 @@ func (n *BlockNode) Render(w io.Writer, ctx *RenderContext) error {
// Determine which content to use - from context blocks or default
var content []Node
- // If we have blocks defined in the context (e.g., from extends), use those
+ // Store the current block content as parent content if needed
+ // This is critical for multi-level inheritance
+ if _, exists := ctx.parentBlocks[n.name]; !exists {
+ // First time we've seen this block - store its original content
+ // This needs to happen for any block, not just in extending templates
+ if blockContent, ok := ctx.blocks[n.name]; ok && len(blockContent) > 0 {
+ // Store the content from blocks
+ ctx.parentBlocks[n.name] = blockContent
+ } else {
+ // Otherwise store the default body
+ ctx.parentBlocks[n.name] = n.body
+ }
+ }
+
+ // Now get the content to render
if blockContent, ok := ctx.blocks[n.name]; ok && len(blockContent) > 0 {
content = blockContent
} else {
@@ -629,9 +643,13 @@ func (n *BlockNode) Render(w io.Writer, ctx *RenderContext) error {
previousBlock := ctx.currentBlock
ctx.currentBlock = n
+ // Create an isolated context for rendering this block
+ // This prevents parent() from accessing the wrong block context
+ blockCtx := ctx
+
// Render the appropriate content
for _, node := range content {
- err := node.Render(w, ctx)
+ err := node.Render(w, blockCtx)
if err != nil {
return err
}
@@ -711,7 +729,29 @@ func (n *ExtendsNode) Render(w io.Writer, ctx *RenderContext) error {
// Ensure the context is released even if an error occurs
defer parentCtx.Release()
- // Copy all block definitions from the child context to the parent context
+ // First, copy any existing parent blocks to maintain the inheritance chain
+ // This allows for multi-level parent() calls to work properly
+ for name, nodes := range ctx.parentBlocks {
+ // Copy to the new context to preserve the inheritance chain
+ parentCtx.parentBlocks[name] = nodes
+ }
+
+ // Extract blocks from the parent template and store them as parent blocks
+ // for any blocks defined in the child but not yet in the parent chain
+ if rootNode, ok := parentTemplate.nodes.(*RootNode); ok {
+ for _, child := range rootNode.Children() {
+ if block, ok := child.(*BlockNode); ok {
+ // If we don't already have a parent for this block,
+ // use the parent template's block definition
+ if _, exists := parentCtx.parentBlocks[block.name]; !exists {
+ parentCtx.parentBlocks[block.name] = block.body
+ }
+ }
+ }
+ }
+
+ // Finally, copy all block definitions from the child context
+ // These are the blocks that will actually be rendered
for name, nodes := range ctx.blocks {
parentCtx.blocks[name] = nodes
}
@@ -1380,12 +1420,13 @@ func (n *RootNode) Render(w io.Writer, ctx *RenderContext) error {
hasChildBlocks = true
}
- // Collect blocks but only if they don't already exist from a child template
+ // First register all blocks in this template before processing extends
+ // Needed to ensure all blocks are available for parent() calls
for _, child := range n.children {
if block, ok := child.(*BlockNode); ok {
- // If child blocks exist, don't override them
+ // Only register blocks that haven't been defined by a child template
if !hasChildBlocks || ctx.blocks[block.name] == nil {
- // Store the blocks from this template
+ // Register the block
ctx.blocks[block.name] = block.body
}
} else if ext, ok := child.(*ExtendsNode); ok {
@@ -1394,9 +1435,10 @@ func (n *RootNode) Render(w io.Writer, ctx *RenderContext) error {
}
}
- // If this template extends another, handle differently
+ // If this template extends another, handle that first
if extendsNode != nil {
- // Render the extends node, which will load and render the parent template
+ // Let the extends node handle the rendering, passing along
+ // all our blocks so they're available to the parent template
return extendsNode.Render(w, ctx)
}
@@ -1470,12 +1512,25 @@ func (n *PrintNode) Render(w io.Writer, ctx *RenderContext) error {
return err
}
- // Check if result is a callable (for macros)
+ // Check if result is a callable for macros
if callable, ok := result.(func(io.Writer) error); ok {
// Execute the callable directly
return callable(w)
}
+ // Handle special case for parent() function which returns func(*RenderContext)(interface{}, error)
+ if parentFunc, ok := result.(func(*RenderContext) (interface{}, error)); ok {
+ // This is the parent function - execute it with the current context
+ parentResult, err := parentFunc(ctx)
+ if err != nil {
+ return err
+ }
+
+ // Write the parent result
+ _, err = WriteString(w, ctx.ToString(parentResult))
+ return err
+ }
+
// Convert result to string
var str string
diff --git a/parent_function_test.go b/parent_function_test.go
new file mode 100644
index 0000000..18891c2
--- /dev/null
+++ b/parent_function_test.go
@@ -0,0 +1,269 @@
+package twig
+
+import (
+ "testing"
+)
+
+func TestParentFunction(t *testing.T) {
+ engine := New()
+
+ // Create a simple parent-child template relationship
+ baseTemplate := `
+
+
+ {% block test %}
+
This is the parent content
+ {% endblock %}
+
Child heading
+ {{ parent() }}
+ Child footer
+{% endblock %}
+`
+
+ // Register the templates
+ engine.RegisterString("base.twig", baseTemplate)
+ engine.RegisterString("child.twig", childTemplate)
+
+ // Render the child template
+ output, err := engine.Render("child.twig", nil)
+ if err != nil {
+ t.Fatalf("Failed to render template: %v", err)
+ }
+
+ // Print the output for debugging
+ t.Logf("Rendered output:\n%s", output)
+
+ // Check for expected content
+ mustContain(t, output, "BASE TEMPLATE")
+ mustContain(t, output, "Child heading")
+ mustContain(t, output, "This is the parent content")
+ mustContain(t, output, "Child footer")
+
+ // Verify ordering
+ inOrderCheck(t, output, "Child heading", "This is the parent content")
+ inOrderCheck(t, output, "This is the parent content", "Child footer")
+}
+
+func TestNestedParentFunction(t *testing.T) {
+ // Test multi-level inheritance with parent() functionality
+ engine := New()
+
+ // Create a simple parent-child relationship
+ baseTemplate := `
+{% block content %}
+Base content
+{% endblock %}
+`
+
+ // Skip the middle template and test direct parent-child
+ childTemplate := `
+{% extends "base.twig" %}
+{% block content %}
+Child content
+{{ parent() }}
+More child content
+{% endblock %}
+`
+
+ engine.RegisterString("base.twig", baseTemplate)
+ engine.RegisterString("child.twig", childTemplate)
+
+ // Render the child template
+ output, err := engine.Render("child.twig", nil)
+ if err != nil {
+ t.Fatalf("Failed to render template: %v", err)
+ }
+
+ // Print the output for debugging
+ t.Logf("Rendered output:\n%s", output)
+
+ // Check that content from parent and child is properly included
+ mustContain(t, output, "BASE TEMPLATE")
+ mustContain(t, output, "Base content")
+ mustContain(t, output, "Child content")
+ mustContain(t, output, "More child content")
+
+ // Verify ordering
+ inOrderCheck(t, output, "Child content", "Base content")
+ inOrderCheck(t, output, "Base content", "More child content")
+}
+
+func TestSimpleMultiLevelParentFunction(t *testing.T) {
+ // A simpler test with just two levels to isolate the issue
+ engine := New()
+
+ // Enable debug mode
+ SetDebugLevel(DebugInfo)
+ engine.SetDebug(true)
+
+ // Create a simpler template hierarchy with just parent and child
+ baseTemplate := `
+{% block content %}
+Base content
+{% endblock %}
+`
+
+ // Middle template with parent() call
+ middleTemplate := `
+{% extends "base.twig" %}
+{% block content %}
+
+ {{ parent() }}
+
Middle content
+
Base content
+{% endblock %}
+`
+
+ // Middle template with parent() call
+ middleTemplate := `
+{% extends "base.twig" %}
+{% block content %}
+
+
Middle content before parent
+ {{ parent() }}
+
Middle content after parent
+
+
Child content
+ {{ parent() }}
+
+{% endblock %}
+`
+
+ // Register the templates
+ engine.RegisterString("base.twig", baseTemplate)
+ engine.RegisterString("middle.twig", middleTemplate)
+ engine.RegisterString("child.twig", childTemplate)
+
+ // Render the child template which should access both parent and grandparent
+ output, err := engine.Render("child.twig", nil)
+ if err != nil {
+ t.Fatalf("Failed to render template: %v", err)
+ }
+
+ // Print the output for debugging
+ t.Logf("Rendered output:\n%s", output)
+
+ // Test the output
+ mustContain(t, output, "BASE TEMPLATE")
+ mustContain(t, output, "Base content")
+ mustContain(t, output, "Middle content")
+ mustContain(t, output, "Child header")
+ mustContain(t, output, "Child footer")
+
+ // Check order of content - should nest properly
+ inOrderCheck(t, output, "Child header", "Base content")
+ inOrderCheck(t, output, "Base content", "Middle content")
+ inOrderCheck(t, output, "Middle content", "Child footer")
+}
+
+func TestParentFunctionErrors(t *testing.T) {
+ engine := New()
+
+ // Test parent() outside of a block
+ template := `{{ parent() }}`
+ engine.RegisterString("bad.twig", template)
+
+ _, err := engine.Render("bad.twig", nil)
+ if err == nil {
+ t.Errorf("Expected an error when calling parent() outside of a block")
+ }
+
+ // Test parent() in a template without inheritance
+ template2 := `{% block test %}{{ parent() }}{% endblock %}`
+ engine.RegisterString("no_parent.twig", template2)
+
+ _, err = engine.Render("no_parent.twig", nil)
+ if err == nil {
+ t.Errorf("Expected an error when calling parent() in a template without inheritance")
+ }
+}
+
+// Helper functions for tests
+func stringContains(haystack, needle string) bool {
+ return stringIndexOf(haystack, needle) >= 0
+}
+
+func stringIndexOf(haystack, needle string) int {
+ for i := 0; i <= len(haystack)-len(needle); i++ {
+ if haystack[i:i+len(needle)] == needle {
+ return i
+ }
+ }
+ return -1
+}
+
+func inOrder(haystack, firstNeedle, secondNeedle string) bool {
+ firstIndex := stringIndexOf(haystack, firstNeedle)
+ secondIndex := stringIndexOf(haystack, secondNeedle)
+ return firstIndex != -1 && secondIndex != -1 && firstIndex < secondIndex
+}
+
+func mustContain(t *testing.T, haystack, needle string) {
+ if !stringContains(haystack, needle) {
+ t.Errorf("Expected output to contain '%s', but it didn't", needle)
+ }
+}
+
+func inOrderCheck(t *testing.T, haystack, firstNeedle, secondNeedle string) {
+ if !inOrder(haystack, firstNeedle, secondNeedle) {
+ if !stringContains(haystack, firstNeedle) {
+ t.Errorf("First string '%s' not found in output", firstNeedle)
+ } else if !stringContains(haystack, secondNeedle) {
+ t.Errorf("Second string '%s' not found in output", secondNeedle)
+ } else {
+ t.Errorf("Expected '%s' to come before '%s' in output", firstNeedle, secondNeedle)
+ }
+ }
+}
diff --git a/render.go b/render.go
index a4e0f85..7356080 100644
--- a/render.go
+++ b/render.go
@@ -20,20 +20,23 @@ type RenderContext struct {
env *Environment
context map[string]interface{}
blocks map[string][]Node
+ parentBlocks map[string][]Node // Original block content from parent templates
macros map[string]Node
parent *RenderContext
engine *Engine // Reference to engine for loading templates
extending bool // Whether this template extends another
currentBlock *BlockNode // Current block being rendered (for parent() function)
+ inParentCall bool // Flag to indicate if we're currently rendering a parent() call
}
// renderContextPool is a sync.Pool for RenderContext objects
var renderContextPool = sync.Pool{
New: func() interface{} {
return &RenderContext{
- context: make(map[string]interface{}),
- blocks: make(map[string][]Node),
- macros: make(map[string]Node),
+ context: make(map[string]interface{}),
+ blocks: make(map[string][]Node),
+ parentBlocks: make(map[string][]Node),
+ macros: make(map[string]Node),
}
},
}
@@ -58,6 +61,7 @@ func NewRenderContext(env *Environment, context map[string]interface{}, engine *
ctx.extending = false
ctx.currentBlock = nil
ctx.parent = nil
+ ctx.inParentCall = false
// Copy the context values
if context != nil {
@@ -83,6 +87,9 @@ func (ctx *RenderContext) Release() {
for k := range ctx.blocks {
delete(ctx.blocks, k)
}
+ for k := range ctx.parentBlocks {
+ delete(ctx.parentBlocks, k)
+ }
for k := range ctx.macros {
delete(ctx.macros, k)
}
@@ -279,6 +286,12 @@ func (ctx *RenderContext) CallFunction(name string, args []interface{}) (interfa
// Check if it's a function in the environment
if ctx.env != nil {
if fn, ok := ctx.env.functions[name]; ok {
+ // Special case for parent() function which needs access to the RenderContext
+ if name == "parent" {
+ return fn(args...)
+ }
+
+ // Regular function call
return fn(args...)
}
}
diff --git a/twig.go b/twig.go
index e736bbf..5bbcc0e 100644
--- a/twig.go
+++ b/twig.go
@@ -634,6 +634,30 @@ func (t *Template) SaveCompiled() ([]byte, error) {
return SerializeCompiledTemplate(compiled)
}
+// GetBlock finds a block in the template by name
+func (t *Template) GetBlock(name string) (*BlockNode, bool) {
+ // If the template has no nodes, return false
+ if t.nodes == nil {
+ return nil, false
+ }
+
+ // Find blocks in the template
+ switch rootNode := t.nodes.(type) {
+ case *RootNode:
+ // Search through all nodes in the root
+ for _, node := range rootNode.Children() {
+ if blockNode, ok := node.(*BlockNode); ok {
+ if blockNode.name == name {
+ return blockNode, true
+ }
+ }
+ }
+ }
+
+ // No matching block found
+ return nil, false
+}
+
// StringBuffer is a simple buffer for string building
type StringBuffer struct {
buf bytes.Buffer