}, document.FirstChild)
// Replace template functions in the root before we add any subsources
- // fmt.Println(root.TemplateFuncs())
htmltree.Walk(document, func(n *html.Node) (bool, error) {
replaceTemplateFuncs(root, n)
return false, nil
for fname, f := range templateSource.TemplateFuncs() {
templateFuncs[snakeCase(n.Data)+"_"+fname] = f
}
- // Add $today_parent before template sources
+ // Add parent scoping
n.Parent.InsertBefore(&html.Node{
Type: html.TextNode,
- Data: "{{ $today_parent := . }}",
+ Data: "{{ call $today_upParent . }}",
}, n)
+ n.Parent.InsertBefore(&html.Node{
+ Type: html.TextNode,
+ Data: "{{ call $today_downParent }}",
+ }, n.NextSibling)
// Parse HTML fragment and replace the content of the node with it
computeSubSource, err := insertTemplateSource(lang, templateSource, n)
if err != nil {
// POSTPROCESSING
- // Assign .SetDot to $setDot
+ // Assign functions
+ funcAssigns := `{{ $today_setDot := .SetDot }}
+ {{ $today_upParent := .UpParent }}
+ {{ $today_downParent := .DownParent }}`
document.InsertBefore(&html.Node{
Type: html.TextNode,
- Data: `{{ $setDot := .SetDot }}{{ with .Data }}`,
+ Data: funcAssigns + `{{ with .Data }}`,
}, document.FirstChild)
// Add end to end
document.InsertBefore(&html.Node{
// Split up templates in text nodes
splitTemplateNodes(document)
- // Traverse the document and add $setDot on entry and exit from pipelines
+ // Traverse the document and add $today_setDot on entry and exit from pipelines
addSetDots(document)
for _, tf := range transform {
package compile
import (
+ "errors"
"fmt"
"net/http"
"reflect"
compute render.OnLoadFunc
asDataFromParent map[string]string
children []*computeNode
+
+ setDot func(any) error
+ upParent func(any) error
+ downParent func() error
}
-func (root *computeNode) Compute(r *http.Request) (render.Data, func(any) error, error) {
- var dot any
- setDot := func(val any) error {
+func (root *computeNode) Compute(r *http.Request) (render.Data, error) {
+ var dot, parent any
+ var parentStack []any
+ root.setDot = func(val any) error {
dot = val
return nil
}
+ root.upParent = func(val any) error {
+ parent = val
+ parentStack = append(parentStack, val)
+ return nil
+ }
+ root.downParent = func() error {
+ if len(parentStack) == 0 {
+ return errors.New("unbalanced parent stack control")
+ } else if len(parentStack) == 1 {
+ parent = nil
+ } else {
+ parent = parentStack[len(parentStack)-1]
+ }
+ parentStack = parentStack[:len(parentStack)-1]
+ return nil
+ }
ctx := r.Context()
var f func(n *computeNode, data render.Data) error
}
childData.Set(dataKey, val)
}
+ childData.Set("today_parent", parent)
f(child, childData)
return childData, child.compute(ctx, childData)
})
}
data := render.NewData(r)
- return data, setDot, f(root, data)
+ return data, f(root, data)
+}
+
+func (root *computeNode) SetDot(val any) error {
+ return root.setDot(val)
+}
+
+func (root *computeNode) UpParent(val any) error {
+ return root.upParent(val)
+}
+
+func (root *computeNode) DownParent() error {
+ return root.downParent()
}
// Get a variable from data.
// EXTREMELY lazy snake caser
func snakeCase(s string) string {
- return strings.ToLower(strings.Replace(s, "-", "_", -1))
+ return strings.ToLower(strings.ReplaceAll(s, "-", "_"))
}
import (
"errors"
"fmt"
+ "math/rand/v2"
"regexp"
"slices"
"strings"
inAttrs && isDataAttr[i] {
// special case; . is parentable but shouldn't be appended
if token == "." {
- token = "$today_parent"
+ token = ".today_parent"
} else {
- token = "$today_parent" + token
+ token = ".today_parent" + token
}
}
output = append(output, token)
func insertTemplateSource(lang language.Tag, subSource TemplateSource, context *html.Node) (*computeNode, error) {
computedName := snakeCase(subSource.Name())
// ===== CONTEXT PREPROCESSING =====
- // Raise any fields pre-existing in the context to $today_parent.field.
+ // Raise any fields pre-existing in the context to .today_parent.field.
raiseDepth := 0
raiseStack := []string{}
htmltree.Walk(context.FirstChild, func(n *html.Node) (bool, error) {
}
// Generate a computeNode for this part.
- htmlId := getAttr(context, "id")
- scopeName := computedName + "_" + snakeCase(htmlId)
- if htmlId == "" || containsTemplate(htmlId) {
- htmlId = ""
- scopeName = computedName
- }
+ computeId := fmt.Sprintf("%x", rand.Int32())
+ scopeName := computedName + "_" + computeId
compute := &computeNode{
name: computedName,
- htmlId: htmlId,
+ htmlId: computeId,
compute: subSource.OnLoad(),
asDataFromParent: asData,
}
if setsDot(n.Data) {
n.Parent.InsertBefore(&html.Node{
Type: html.TextNode,
- Data: `{{ call $setDot . }}`,
+ Data: `{{ call $today_setDot . }}`,
}, n.NextSibling)
endAcc = append(endAcc, true)
} else {
if shouldSet {
n.Parent.InsertBefore(&html.Node{
Type: html.TextNode,
- Data: "{{ call $setDot . }}",
+ Data: "{{ call $today_setDot . }}",
}, n.NextSibling)
}
if strings.Contains(n.Data, "else") {
)
type RootData struct {
- SetDot func(value any) error
+ SetDot func(value any) error
+ UpParent func(value any) error
+ DownParent func() error
Data render.Data
}
func (p *Page) ServeHTTP(w http.ResponseWriter, r *http.Request) {
toRender := p.chooseRenderable(r)
- data, setDot, err := toRender.templateLoad.Compute(r)
+ loader := toRender.templateLoad
+ data, err := loader.Compute(r)
if err != nil {
panic(err)
}
root := RootData{
- SetDot: setDot,
+ SetDot: loader.SetDot,
+ UpParent: loader.UpParent,
+ DownParent: loader.DownParent,
Data: data,
}
type OnLoadFunc func(ctx context.Context, data Data) error
type Loader interface {
- Compute(r *http.Request) (Data, func(any) error, error)
+ Compute(r *http.Request) (Data, error)
+ SetDot(val any) error
+ UpParent(val any) error
+ DownParent() error
}
projects / today / commitdiff