Initial commit, rejoice!

.gitignore

···
+dev/
+.claude

README.md

···
+# GOTT - Go Template Toolkit
+
+A templating system very much inspired by Perl's Template module (The Template Toolkit). There are other templating packages available, of course, but I really wanted the `[% WRAPPER %]`, `[% BLOCK %]` and `[% INCLUDE %]` directives. 
+
+This is just a pet project I built for myself, to see if a) I could actually understand/write Go, and b) to see what value a tool like Claude brings to the table. So, YMMV! 
+
+## Usage
+
+Import the package, and instantiate a new renderer:
+
+```go
+renderer := gott.New(&gott.Config{
+    ...
+})
+```
+
+The `gott.Config` contains the following fields:
+
+- IncludePaths: `[]fs.FS`
+- Filters: `map[string]func(string, ...string) string`
+
+The include paths are tried left to right when a template needs rendering; this can be used for instance to do this:
+
+```go
+renderer := gott.New(&gott.Config{
+    IncludePaths: []fs.FS{
+        os.DirFS("..."),
+        embeddedFS
+    })
+```
+
+To have files on disk tried first, and if the requested template wasn't found, fall back to an embedded FS (via `embed`). 
+
+Filters are functions that filter variables in templates, for instance one could write a filter that turns everything to upper, or to truncate a string to a given length. 
+
+```go
+import "strings"
+
+func filterUpper(content string, args ...string) string {
+    return strings.ToUpper(content)
+}
+
+func filterTruncate(s string, args ...string) string {
+    if len(args) == 0 {
+        return s
+    }
+    maxLen := 0
+    fmt.Sscanf(args[0], "%d", &maxLen)
+    if maxLen <= 0 || len(s) <= maxLen {
+        return s
+    }
+    return s[:maxLen-3] + "..."
+}
+renderer := gott.New(&gott.Config{
+    Filters: map[string]func(string, ...string) string{
+        upper: filterUpper,
+        truncate: filterTruncate,
+    })
+```
+
+For convenience. the renderer has an `AddFilter` method:
+
+```go
+renderer.AddFilter("truncate", filterTruncate)
+```
+
+To render content, there are a few methods available:
+
+```go
+// Render takes a http.ResponseWriter, string, and a map[string]any and will attempt to render the given template
+// and writes it to the client as text/html; a 404 error is rendered for templates that aren't found, 500 error is 
+// rendered if something goes kaka
+renderer.Render(w, "mytemplate", map[string]any{myvariable:"foo", userCount: 10})
+
+// Identical to Render except it lets you override the status code; I have one project that actually renders html
+// with a 420 (made up) status code because reasons. Something tech debt-ish. 
+renderer.RenderWithStatus(w, int, string, map[string]any) 
+
+// Render JSON data, will render a 500 error if marshalling failed; takes a http.ResponseWriter and 'any' as parameter
+renderer.RenderJSON(w, map[string]any{status:"error",errorCode: 200, errorMessage: "it done blew up"})
+
+// Same as above but takes the ResponseWriter, status code, and the data that needs to be marshalled
+renderer.RenderJSONWithStatus(w, int, any) 
+
+// Silly little function to render a blank HTTP 204 response 
+renderer.Render204() 
+```
+
+## Concepts 
+
+### Filters
+
+Filters are simple functions that transform variable content. These should be short and to the point, and should not be used to perform any sort of external lookup or other network requests. Filters can take parameters (e.g. `truncate(30)`) but all parameters are passed as strings, so you'll have to do the proper processing on them in the filter func. 
+
+The following filters are built-in:
+
+- *upper*: turns the variable to all uppercase
+- *lower*: turns the variable to all lowercase
+- *html*: makes the variable safe to render in HTML (e.g. "<foo>" is turned into "&gt;foo&lt;" 
+- *uri*: makes the variable safe to use as an URI fragment;
+
+### Virtual Methods
+
+Virtual methods are, well, methods that one can call on a variable. For instance, given a variable of signature `[]string{"foo","bar","baz"}`, you can use this construct to ge the last element: [% variable.last %]. 
+
+The following virtual methods are built-in:
+
+- *exists*: Will return true if the given variable actually exists in the data passed to the renderer, does not check for defined-ness, purely existence. 
+- *defined*: Will return true if the given variable exists in the data passed to the renderer, and is not empty (insofar a variable can be empty in go) 
+- *length/size*: Will return the length of the variable; handles strings, slices, maps
+- *first/last*: Will return the first or last element of a slice 
+
+You can add your own virtual methods with the `AddVirtualMethod` method on the renderer, for instance: 
+
+```go
+renderer.addVirtualMethod("methodname", func(data any) (any, bool) {
+    
+})
+```
+
+A virtual method handler should return whatever data it wants, plus a boolean indicating whether the operation was successful.  
+
+## Variables and interpolation
+
+Variables are passed to the renderer as a `map[string]any` and can be interpolated into a template via the following syntax:
+
+```go
+// simple variable
+[% myvariable %]
+
+// nested variable, e.g. variable is a map
+[% myvariable.somekey %]
+
+// but it could also be a vmethod 
+[% myvariable.length %]
+
+// if variable is not defined, add a default
+[% user.name || "User doesn't have a name, strange!" %]
+
+// variable with filtering
+[% userEnteredHTML |html %] 
+
+// filter chaining
+[% verylongname |truncate(20)|upper %] 
+
+// vmethods and defaults and filters, oh my (this would work as you think it would because a value of 0
+// is considered "not truthy"
+[% records.length || "no records found" |somefilter|anotherfilter %]  
+
+```
+
+The following comparison operators are available: `== != < <= => >` 
+The following logic operators are available: `&& ||`
+The following arithmetic operators are available: `+ - * / %`
+
+Strings can be concatenated using `+` if either the lvalue or rvalue is a string. Given the following data:
+
+```
+data := map[string]any{version: "1.2.3", versionNumeric: 123}
+
+// renders "1.2.3-dev"
+[% version + "-dev" %] 
+
+// renders "123-dev" 
+[% versionNumeric + "-dev" %]
+
+// renders 124
+[% versionNumeric + 1 %]
+
+// renders 1-1.2.3 
+[% "1-" + version %]
+
+```
+
+## Directives 
+
+The following directives are supported:
+
+```go
+// logic
+[% IF myvariable == "yes" %] 
+    Yes!
+[% ELSIF myvariable == "maybe" %]
+    Maybe?
+[% ELSE %]
+    No...
+[% END %]
+
+// this construct is a Perlism
+[% UNLESS user.isAdmin %]
+    Not the admin
+[% END %]
+
+// include another template
+[% INCLUDE other/template.html %]
+
+// include a previously defined block
+[% INCLUDE myshinyblock %]
+
+// define a block
+[% BLOCK myshinyblock %]
+    [% entry.name %]
+[% END %]
+
+// iterate a slice; a foreach can be nested, and a foreach can use all other directives in it's repeated block 
+[% FOREACH entry IN myslice %]
+    [% INCLUDE myshinyblock %]
+[% END %]
+
+// iterate a map
+[% FOREACH entry IN mymap %]
+    [% entry.key %] = [% entry.value %]
+[% END %]
+
+// wrap content in another template
+// wrapper template content should contain a single `[% content %]` variable where the content it is wrapping will appear
+[% WRAPPER wrap/me/in/this.html %]
+    content that can use any other directive
+[% END %]
+
+## Author/Disclosure
+
+Author: Ben van Staveren/AngryDutchman <[e-mail]> 
+Co-Author: Claude (see below)
+
+Heavily inspired by Perl's [Template Toolkit](https://metacpan.org/pod/Template), by Andy Wardley 
+
+### Claude usage
+
+Claude is used to add comments in places that should have them but don't (because I'm awful at doing it), and to take my not-so-efficient implementations and make them more efficient. Claude is also used to solve fun directive parsing problems, and to do refactoring work. All code generated by Claude is vetted and looked at. 

ast.go

···
+package gott
+
+// Node is the interface implemented by all AST nodes
+type Node interface {
+    Pos() Position // position of the first token of this node
+    node()         // marker method to ensure only AST types implement Node
+}
+
+// Expr is the interface implemented by all expression nodes
+type Expr interface {
+    Node
+    expr() // marker method
+}
+
+// Stmt is the interface implemented by all statement nodes
+type Stmt interface {
+    Node
+    stmt() // marker method
+}
+
+// ---- Template (root node) ----
+
+// Template is the root node containing all parsed nodes
+type Template struct {
+    Position Position
+    Nodes    []Node // mix of TextNode, statements, and output expressions
+}
+
+func (t *Template) Pos() Position { return t.Position }
+func (t *Template) node()         {}
+
+// ---- Literal/Text Nodes ----
+
+// TextNode holds literal text outside of tags
+type TextNode struct {
+    Position Position
+    Text     string
+}
+
+func (n *TextNode) Pos() Position { return n.Position }
+func (n *TextNode) node()         {}
+
+// ---- Expression Nodes ----
+
+// IdentExpr represents a variable reference with optional dot notation
+// e.g., "foo", "foo.bar", "foo.bar.baz"
+type IdentExpr struct {
+    Position Position
+    Parts    []string // ["foo", "bar", "baz"] for foo.bar.baz
+}
+
+func (e *IdentExpr) Pos() Position { return e.Position }
+func (e *IdentExpr) node()         {}
+func (e *IdentExpr) expr()         {}
+
+// LiteralExpr holds a string or number literal
+type LiteralExpr struct {
+    Position Position
+    Value    any // string or float64
+}
+
+func (e *LiteralExpr) Pos() Position { return e.Position }
+func (e *LiteralExpr) node()         {}
+func (e *LiteralExpr) expr()         {}
+
+// BinaryExpr represents a binary operation: left op right
+type BinaryExpr struct {
+    Position Position
+    Op       TokenType
+    Left     Expr
+    Right    Expr
+}
+
+func (e *BinaryExpr) Pos() Position { return e.Position }
+func (e *BinaryExpr) node()         {}
+func (e *BinaryExpr) expr()         {}
+
+// UnaryExpr represents a unary operation: op expr
+type UnaryExpr struct {
+    Position Position
+    Op       TokenType
+    X        Expr
+}
+
+func (e *UnaryExpr) Pos() Position { return e.Position }
+func (e *UnaryExpr) node()         {}
+func (e *UnaryExpr) expr()         {}
+
+// CallExpr represents a function call: func(args...)
+type CallExpr struct {
+    Position Position
+    Func     string
+    Args     []Expr
+}
+
+func (e *CallExpr) Pos() Position { return e.Position }
+func (e *CallExpr) node()         {}
+func (e *CallExpr) expr()         {}
+
+// FilterExpr represents a filter application: expr | filter or expr | filter(args)
+type FilterExpr struct {
+    Position Position
+    Input    Expr
+    Filter   string
+    Args     []Expr
+}
+
+func (e *FilterExpr) Pos() Position { return e.Position }
+func (e *FilterExpr) node()         {}
+func (e *FilterExpr) expr()         {}
+
+// DefaultExpr represents a default value expression: expr || default
+type DefaultExpr struct {
+    Position Position
+    Expr     Expr
+    Default  Expr
+}
+
+func (e *DefaultExpr) Pos() Position { return e.Position }
+func (e *DefaultExpr) node()         {}
+func (e *DefaultExpr) expr()         {}
+
+// ---- Statement Nodes ----
+
+// OutputStmt represents an expression to be output: [% expr %]
+type OutputStmt struct {
+    Position Position
+    Expr     Expr
+}
+
+func (s *OutputStmt) Pos() Position { return s.Position }
+func (s *OutputStmt) node()         {}
+func (s *OutputStmt) stmt()         {}
+
+// IfStmt represents an IF/ELSIF/ELSE chain
+type IfStmt struct {
+    Position  Position
+    Condition Expr
+    Body      []Node
+    ElsIf     []*ElsIfClause // zero or more ELSIF clauses
+    Else      []Node         // optional ELSE body
+}
+
+func (s *IfStmt) Pos() Position { return s.Position }
+func (s *IfStmt) node()         {}
+func (s *IfStmt) stmt()         {}
+
+// ElsIfClause represents an ELSIF branch
+type ElsIfClause struct {
+    Position  Position
+    Condition Expr
+    Body      []Node
+}
+
+// UnlessStmt represents an UNLESS conditional
+type UnlessStmt struct {
+    Position  Position
+    Condition Expr
+    Body      []Node
+    Else      []Node // optional ELSE body
+}
+
+func (s *UnlessStmt) Pos() Position { return s.Position }
+func (s *UnlessStmt) node()         {}
+func (s *UnlessStmt) stmt()         {}
+
+// ForeachStmt represents a FOREACH loop
+type ForeachStmt struct {
+    Position Position
+    ItemVar  string // loop variable name
+    ListExpr Expr   // expression for the list/map to iterate
+    Body     []Node
+}
+
+func (s *ForeachStmt) Pos() Position { return s.Position }
+func (s *ForeachStmt) node()         {}
+func (s *ForeachStmt) stmt()         {}
+
+// BlockStmt represents a named block definition
+type BlockStmt struct {
+    Position Position
+    Name     string
+    Body     []Node
+}
+
+func (s *BlockStmt) Pos() Position { return s.Position }
+func (s *BlockStmt) node()         {}
+func (s *BlockStmt) stmt()         {}
+
+// IncludeStmt represents an INCLUDE directive
+type IncludeStmt struct {
+    Position Position
+    Name     string // block name or file path
+}
+
+func (s *IncludeStmt) Pos() Position { return s.Position }
+func (s *IncludeStmt) node()         {}
+func (s *IncludeStmt) stmt()         {}
+
+// WrapperStmt represents a WRAPPER directive
+type WrapperStmt struct {
+    Position Position
+    Name     string // wrapper template name
+    Content  []Node // content to be wrapped
+}
+
+func (s *WrapperStmt) Pos() Position { return s.Position }
+func (s *WrapperStmt) node()         {}
+func (s *WrapperStmt) stmt()         {}
+
+// SetStmt represents a SET variable assignment
+type SetStmt struct {
+    Position Position
+    Var      string
+    Value    Expr
+}
+
+func (s *SetStmt) Pos() Position { return s.Position }
+func (s *SetStmt) node()         {}
+func (s *SetStmt) stmt()         {}

eval.go

···
+package gott
+
+import (
+    "fmt"
+    "reflect"
+    "sort"
+    "strconv"
+    "strings"
+)
+
+// Evaluator evaluates an AST with the given variables
+type Evaluator struct {
+    renderer *Renderer          // for filters, virtual methods, includes
+    vars     map[string]any     // current variable scope
+    blocks   map[string]*BlockStmt // defined blocks
+    output   strings.Builder    // accumulated output
+}
+
+// NewEvaluator creates a new evaluator
+func NewEvaluator(r *Renderer, vars map[string]any) *Evaluator {
+    if vars == nil {
+        vars = make(map[string]any)
+    }
+    return &Evaluator{
+        renderer: r,
+        vars:     vars,
+        blocks:   make(map[string]*BlockStmt),
+    }
+}
+
+// Eval evaluates the template and returns the output string
+func (e *Evaluator) Eval(t *Template) (string, error) {
+    // First pass: collect block definitions
+    for _, node := range t.Nodes {
+        if block, ok := node.(*BlockStmt); ok {
+            e.blocks[block.Name] = block
+        }
+    }
+
+    // Second pass: evaluate nodes
+    for _, node := range t.Nodes {
+        // Skip block definitions in output (they're just definitions)
+        if _, ok := node.(*BlockStmt); ok {
+            continue
+        }
+        if err := e.evalNode(node); err != nil {
+            return "", err
+        }
+    }
+
+    return e.output.String(), nil
+}
+
+// evalNode evaluates a single AST node
+func (e *Evaluator) evalNode(node Node) error {
+    switch n := node.(type) {
+    case *TextNode:
+        e.output.WriteString(n.Text)
+
+    case *OutputStmt:
+        val, err := e.evalExpr(n.Expr)
+        if err != nil {
+            return err
+        }
+        if val != nil {
+            e.output.WriteString(e.toString(val))
+        }
+
+    case *IfStmt:
+        return e.evalIf(n)
+
+    case *UnlessStmt:
+        return e.evalUnless(n)
+
+    case *ForeachStmt:
+        return e.evalForeach(n)
+
+    case *IncludeStmt:
+        return e.evalInclude(n)
+
+    case *WrapperStmt:
+        return e.evalWrapper(n)
+
+    case *SetStmt:
+        val, err := e.evalExpr(n.Value)
+        if err != nil {
+            return err
+        }
+        e.vars[n.Var] = val
+
+    case *BlockStmt:
+        // Block definitions are handled in first pass, skip here
+    }
+
+    return nil
+}
+
+// evalNodes evaluates a slice of nodes
+func (e *Evaluator) evalNodes(nodes []Node) error {
+    for _, node := range nodes {
+        if err := e.evalNode(node); err != nil {
+            return err
+        }
+    }
+    return nil
+}
+
+// evalIf evaluates an IF statement
+func (e *Evaluator) evalIf(n *IfStmt) error {
+    cond, err := e.evalExpr(n.Condition)
+    if err != nil {
+        return err
+    }
+
+    if e.isTruthy(cond) {
+        return e.evalNodes(n.Body)
+    }
+
+    // Check ELSIF chain
+    for _, elsif := range n.ElsIf {
+        cond, err := e.evalExpr(elsif.Condition)
+        if err != nil {
+            return err
+        }
+        if e.isTruthy(cond) {
+            return e.evalNodes(elsif.Body)
+        }
+    }
+
+    // Fall through to ELSE
+    if n.Else != nil {
+        return e.evalNodes(n.Else)
+    }
+
+    return nil
+}
+
+// evalUnless evaluates an UNLESS statement
+func (e *Evaluator) evalUnless(n *UnlessStmt) error {
+    cond, err := e.evalExpr(n.Condition)
+    if err != nil {
+        return err
+    }
+
+    if !e.isTruthy(cond) {
+        return e.evalNodes(n.Body)
+    }
+
+    if n.Else != nil {
+        return e.evalNodes(n.Else)
+    }
+
+    return nil
+}
+
+// evalForeach evaluates a FOREACH loop
+func (e *Evaluator) evalForeach(n *ForeachStmt) error {
+    list, err := e.evalExpr(n.ListExpr)
+    if err != nil {
+        return err
+    }
+
+    if list == nil {
+        return nil
+    }
+
+    rv := reflect.ValueOf(list)
+
+    switch rv.Kind() {
+    case reflect.Slice, reflect.Array:
+        for i := 0; i < rv.Len(); i++ {
+            // Create new scope with loop variable
+            loopEval := e.withVar(n.ItemVar, rv.Index(i).Interface())
+            if err := loopEval.evalNodes(n.Body); err != nil {
+                return err
+            }
+            e.output.WriteString(loopEval.output.String())
+        }
+
+    case reflect.Map:
+        // TT2-style: iterate as key/value pairs, sorted by key
+        keys := rv.MapKeys()
+        sort.Slice(keys, func(i, j int) bool {
+            return fmt.Sprintf("%v", keys[i].Interface()) < fmt.Sprintf("%v", keys[j].Interface())
+        })
+
+        for _, key := range keys {
+            // Each iteration gets a map with "key" and "value" fields
+            entry := map[string]any{
+                "key":   key.Interface(),
+                "value": rv.MapIndex(key).Interface(),
+            }
+
+            loopEval := e.withVar(n.ItemVar, entry)
+            if err := loopEval.evalNodes(n.Body); err != nil {
+                return err
+            }
+            e.output.WriteString(loopEval.output.String())
+        }
+
+    default:
+        return &EvalError{
+            Pos:     n.Position,
+            Message: fmt.Sprintf("cannot iterate over %T", list),
+        }
+    }
+
+    return nil
+}
+
+// evalInclude evaluates an INCLUDE directive
+func (e *Evaluator) evalInclude(n *IncludeStmt) error {
+    // First check if it's a defined block
+    if block, ok := e.blocks[n.Name]; ok {
+        return e.evalNodes(block.Body)
+    }
+
+    // Otherwise, try to load from filesystem
+    content, err := e.renderer.loadFile(n.Name)
+    if err != nil {
+        e.output.WriteString(fmt.Sprintf("[Include '%s' not found]", n.Name))
+        return nil
+    }
+
+    // Parse and evaluate the included template
+    parser := NewParser(content)
+    tmpl, parseErrs := parser.Parse()
+    if len(parseErrs) > 0 {
+        return parseErrs[0]
+    }
+
+    // Evaluate with same scope
+    includeEval := NewEvaluator(e.renderer, e.copyVars())
+    // Copy blocks
+    for name, block := range e.blocks {
+        includeEval.blocks[name] = block
+    }
+    result, err := includeEval.Eval(tmpl)
+    if err != nil {
+        return err
+    }
+    e.output.WriteString(result)
+
+    return nil
+}
+
+// evalWrapper evaluates a WRAPPER directive
+func (e *Evaluator) evalWrapper(n *WrapperStmt) error {
+    // First, evaluate the wrapped content
+    contentEval := NewEvaluator(e.renderer, e.copyVars())
+    for name, block := range e.blocks {
+        contentEval.blocks[name] = block
+    }
+    for _, node := range n.Content {
+        if err := contentEval.evalNode(node); err != nil {
+            return err
+        }
+    }
+    wrappedContent := contentEval.output.String()
+
+    // Load the wrapper template
+    var wrapperSource string
+    if block, ok := e.blocks[n.Name]; ok {
+        // Wrapper is a defined block - evaluate it
+        blockEval := NewEvaluator(e.renderer, e.copyVars())
+        for name, b := range e.blocks {
+            blockEval.blocks[name] = b
+        }
+        for _, node := range block.Body {
+            if err := blockEval.evalNode(node); err != nil {
+                return err
+            }
+        }
+        wrapperSource = blockEval.output.String()
+    } else {
+        content, err := e.renderer.loadFile(n.Name)
+        if err != nil {
+            e.output.WriteString(fmt.Sprintf("[Wrapper '%s' not found]", n.Name))
+            return nil
+        }
+        wrapperSource = content
+    }
+
+    // Parse the wrapper template
+    parser := NewParser(wrapperSource)
+    tmpl, parseErrs := parser.Parse()
+    if len(parseErrs) > 0 {
+        return parseErrs[0]
+    }
+
+    // Evaluate wrapper with "content" variable set to wrapped content
+    wrapperVars := e.copyVars()
+    wrapperVars["content"] = wrappedContent
+
+    wrapperEval := NewEvaluator(e.renderer, wrapperVars)
+    for name, block := range e.blocks {
+        wrapperEval.blocks[name] = block
+    }
+    result, err := wrapperEval.Eval(tmpl)
+    if err != nil {
+        return err
+    }
+    e.output.WriteString(result)
+
+    return nil
+}
+
+// evalExpr evaluates an expression and returns its value
+func (e *Evaluator) evalExpr(expr Expr) (any, error) {
+    switch x := expr.(type) {
+    case *LiteralExpr:
+        return x.Value, nil
+
+    case *IdentExpr:
+        return e.resolveIdent(x.Parts)
+
+    case *BinaryExpr:
+        return e.evalBinary(x)
+
+    case *UnaryExpr:
+        return e.evalUnary(x)
+
+    case *CallExpr:
+        return e.evalCall(x)
+
+    case *FilterExpr:
+        return e.evalFilter(x)
+
+    case *DefaultExpr:
+        val, err := e.evalExpr(x.Expr)
+        if err != nil || !e.isDefined(val) {
+            return e.evalExpr(x.Default)
+        }
+        return val, nil
+    }
+
+    return nil, fmt.Errorf("unknown expression type: %T", expr)
+}
+
+// evalBinary evaluates a binary expression
+func (e *Evaluator) evalBinary(b *BinaryExpr) (any, error) {
+    left, err := e.evalExpr(b.Left)
+    if err != nil {
+        return nil, err
+    }
+    right, err := e.evalExpr(b.Right)
+    if err != nil {
+        return nil, err
+    }
+
+    switch b.Op {
+    case TokenPlus:
+        // If either operand is a string, do string concatenation
+        if e.isString(left) || e.isString(right) {
+            return e.toString(left) + e.toString(right), nil
+        }
+        return e.toFloat(left) + e.toFloat(right), nil
+
+    case TokenMinus:
+        return e.toFloat(left) - e.toFloat(right), nil
+
+    case TokenMul:
+        return e.toFloat(left) * e.toFloat(right), nil
+
+    case TokenDiv:
+        r := e.toFloat(right)
+        if r == 0 {
+            return nil, &EvalError{Pos: b.Position, Message: "division by zero"}
+        }
+        return e.toFloat(left) / r, nil
+
+    case TokenMod:
+        return int(e.toFloat(left)) % int(e.toFloat(right)), nil
+
+    case TokenEq:
+        return e.equals(left, right), nil
+
+    case TokenNe:
+        return !e.equals(left, right), nil
+
+    case TokenLt:
+        return e.toFloat(left) < e.toFloat(right), nil
+
+    case TokenLe:
+        return e.toFloat(left) <= e.toFloat(right), nil
+
+    case TokenGt:
+        return e.toFloat(left) > e.toFloat(right), nil
+
+    case TokenGe:
+        return e.toFloat(left) >= e.toFloat(right), nil
+
+    case TokenAnd:
+        return e.isTruthy(left) && e.isTruthy(right), nil
+
+    case TokenOr:
+        return e.isTruthy(left) || e.isTruthy(right), nil
+    }
+
+    return nil, fmt.Errorf("unknown operator: %v", b.Op)
+}
+
+// evalUnary evaluates a unary expression
+func (e *Evaluator) evalUnary(u *UnaryExpr) (any, error) {
+    val, err := e.evalExpr(u.X)
+    if err != nil {
+        return nil, err
+    }
+
+    switch u.Op {
+    case TokenMinus:
+        return -e.toFloat(val), nil
+    }
+
+    return nil, fmt.Errorf("unknown unary operator: %v", u.Op)
+}
+
+// evalCall evaluates a function call
+func (e *Evaluator) evalCall(c *CallExpr) (any, error) {
+    fn, ok := e.vars[c.Func]
+    if !ok {
+        return nil, &EvalError{
+            Pos:     c.Position,
+            Message: fmt.Sprintf("undefined function: %s", c.Func),
+        }
+    }
+
+    fnValue := reflect.ValueOf(fn)
+    if fnValue.Kind() != reflect.Func {
+        return nil, &EvalError{
+            Pos:     c.Position,
+            Message: fmt.Sprintf("%s is not a function", c.Func),
+        }
+    }
+
+    var args []reflect.Value
+    for _, arg := range c.Args {
+        val, err := e.evalExpr(arg)
+        if err != nil {
+            return nil, err
+        }
+        args = append(args, reflect.ValueOf(val))
+    }
+
+    results := fnValue.Call(args)
+    if len(results) > 0 {
+        return results[0].Interface(), nil
+    }
+    return nil, nil
+}
+
+// evalFilter evaluates a filter expression
+func (e *Evaluator) evalFilter(f *FilterExpr) (any, error) {
+    input, err := e.evalExpr(f.Input)
+    if err != nil {
+        return nil, err
+    }
+
+    inputStr := e.toString(input)
+
+    filter, ok := e.renderer.getFilter(f.Filter)
+    if !ok {
+        return inputStr + fmt.Sprintf("[Filter '%s' not found]", f.Filter), nil
+    }
+
+    var args []string
+    for _, arg := range f.Args {
+        val, err := e.evalExpr(arg)
+        if err != nil {
+            return nil, err
+        }
+        args = append(args, e.toString(val))
+    }
+
+    return filter(inputStr, args...), nil
+}
+
+// resolveIdent resolves a dot-notation identifier
+func (e *Evaluator) resolveIdent(parts []string) (any, error) {
+    if len(parts) == 0 {
+        return nil, nil
+    }
+
+    // Get the root variable
+    val, ok := e.vars[parts[0]]
+
+    // Handle .exists virtual method at top level
+    if len(parts) == 2 && parts[1] == "exists" {
+        return ok, nil
+    }
+
+    // Handle .defined virtual method at top level
+    if len(parts) == 2 && parts[1] == "defined" {
+        if !ok {
+            return false, nil
+        }
+        return e.isDefined(val), nil
+    }
+
+    if !ok {
+        return nil, nil
+    }
+
+    if len(parts) == 1 {
+        return val, nil
+    }
+
+    // Navigate through the remaining parts
+    for i := 1; i < len(parts); i++ {
+        property := parts[i]
+
+        // Virtual methods
+        if property == "exists" {
+            return true, nil
+        }
+        if property == "defined" {
+            return e.isDefined(val), nil
+        }
+
+        // Check custom virtual methods
+        if method, ok := e.renderer.getVirtualMethod(property); ok {
+            result, _ := method(val)
+            val = result
+            continue
+        }
+
+        // Built-in virtual methods
+        switch property {
+        case "length", "size":
+            switch v := val.(type) {
+            case string:
+                return len(v), nil
+            case map[string]any:
+                return len(v), nil
+            default:
+                rv := reflect.ValueOf(val)
+                if rv.Kind() == reflect.Slice || rv.Kind() == reflect.Array {
+                    return rv.Len(), nil
+                }
+                return nil, nil
+            }
+
+        case "first":
+            rv := reflect.ValueOf(val)
+            if rv.Kind() == reflect.Slice || rv.Kind() == reflect.Array {
+                if rv.Len() > 0 {
+                    val = rv.Index(0).Interface()
+                    continue
+                }
+            }
+            return nil, nil
+
+        case "last":
+            rv := reflect.ValueOf(val)
+            if rv.Kind() == reflect.Slice || rv.Kind() == reflect.Array {
+                if rv.Len() > 0 {
+                    val = rv.Index(rv.Len() - 1).Interface()
+                    continue
+                }
+            }
+            return nil, nil
+
+        default:
+            // Try map access
+            if m, ok := val.(map[string]any); ok {
+                if v, exists := m[property]; exists {
+                    val = v
+                    continue
+                }
+                return nil, nil
+            }
+
+            // Try struct field access via reflection
+            rv := reflect.ValueOf(val)
+            if rv.Kind() == reflect.Ptr {
+                rv = rv.Elem()
+            }
+            if rv.Kind() == reflect.Struct {
+                field := rv.FieldByName(property)
+                if field.IsValid() {
+                    val = field.Interface()
+                    continue
+                }
+            }
+
+            return nil, nil
+        }
+    }
+
+    return val, nil
+}
+
+// ---- Helper methods ----
+
+// withVar creates a new evaluator with an additional variable
+func (e *Evaluator) withVar(name string, value any) *Evaluator {
+    newVars := e.copyVars()
+    newVars[name] = value
+    eval := NewEvaluator(e.renderer, newVars)
+    for k, v := range e.blocks {
+        eval.blocks[k] = v
+    }
+    return eval
+}
+
+// copyVars creates a shallow copy of the variables map
+func (e *Evaluator) copyVars() map[string]any {
+    newVars := make(map[string]any, len(e.vars))
+    for k, v := range e.vars {
+        newVars[k] = v
+    }
+    return newVars
+}
+
+// isTruthy determines if a value is considered "true"
+func (e *Evaluator) isTruthy(val any) bool {
+    if val == nil {
+        return false
+    }
+
+    switch v := val.(type) {
+    case bool:
+        return v
+    case string:
+        return v != ""
+    case int:
+        return v != 0
+    case int64:
+        return v != 0
+    case float64:
+        return v != 0
+    case float32:
+        return v != 0
+    default:
+        rv := reflect.ValueOf(val)
+        switch rv.Kind() {
+        case reflect.Slice, reflect.Array:
+            return rv.Len() > 0
+        case reflect.Map:
+            return rv.Len() > 0
+        }
+        return true
+    }
+}
+
+// isDefined checks if a value is "defined" (non-nil and non-empty for strings)
+func (e *Evaluator) isDefined(val any) bool {
+    if val == nil {
+        return false
+    }
+
+    switch v := val.(type) {
+    case string:
+        return v != ""
+    case map[string]any:
+        return v != nil
+    default:
+        rv := reflect.ValueOf(val)
+        if rv.Kind() == reflect.Slice || rv.Kind() == reflect.Array {
+            return !rv.IsNil()
+        }
+        return true
+    }
+}
+
+// isString checks if a value is a string
+func (e *Evaluator) isString(v any) bool {
+    _, ok := v.(string)
+    return ok
+}
+
+// toString converts a value to string
+func (e *Evaluator) toString(v any) string {
+    switch val := v.(type) {
+    case string:
+        return val
+    case nil:
+        return ""
+    case bool:
+        if val {
+            return "true"
+        }
+        return "false"
+    case float64:
+        if val == float64(int64(val)) {
+            return strconv.FormatInt(int64(val), 10)
+        }
+        return strconv.FormatFloat(val, 'f', -1, 64)
+    case int:
+        return strconv.Itoa(val)
+    case int64:
+        return strconv.FormatInt(val, 10)
+    default:
+        return fmt.Sprintf("%v", val)
+    }
+}
+
+// toFloat converts a value to float64
+func (e *Evaluator) toFloat(v any) float64 {
+    switch val := v.(type) {
+    case float64:
+        return val
+    case float32:
+        return float64(val)
+    case int:
+        return float64(val)
+    case int64:
+        return float64(val)
+    case int32:
+        return float64(val)
+    case string:
+        f, _ := strconv.ParseFloat(val, 64)
+        return f
+    default:
+        return 0
+    }
+}
+
+// equals compares two values for equality
+func (e *Evaluator) equals(left, right any) bool {
+    // Try numeric comparison
+    leftNum, leftOk := e.tryFloat(left)
+    rightNum, rightOk := e.tryFloat(right)
+    if leftOk && rightOk {
+        return leftNum == rightNum
+    }
+
+    // Fall back to string comparison
+    return fmt.Sprintf("%v", left) == fmt.Sprintf("%v", right)
+}
+
+// tryFloat attempts to convert a value to float64
+func (e *Evaluator) tryFloat(v any) (float64, bool) {
+    switch val := v.(type) {
+    case float64:
+        return val, true
+    case float32:
+        return float64(val), true
+    case int:
+        return float64(val), true
+    case int64:
+        return float64(val), true
+    case int32:
+        return float64(val), true
+    case string:
+        if f, err := strconv.ParseFloat(val, 64); err == nil {
+            return f, true
+        }
+    }
+    return 0, false
+}
+
+// ---- Error type ----
+
+// EvalError represents an error during evaluation
+type EvalError struct {
+    Pos     Position
+    Message string
+}
+
+func (e *EvalError) Error() string {
+    return fmt.Sprintf("line %d, column %d: %s", e.Pos.Line, e.Pos.Column, e.Message)
+}
+
+// ParseError represents an error during parsing
+type ParseError struct {
+    Pos     Position
+    Message string
+}
+
+func (e *ParseError) Error() string {
+    return fmt.Sprintf("parse error at line %d, column %d: %s", e.Pos.Line, e.Pos.Column, e.Message)
+}

go.mod

···
+module tangled.org/angrydutchman.peedee.es/gott
+
+go 1.25   
+toolchain go1.25.1
+

gott.go

···
+package gott
+
+import (
+    "encoding/json"
+    "errors"
+    "html"
+    "io/fs"
+    "net/http"
+    "net/url"
+    "strings"
+    "sync"
+)
+
+// Renderer is the main template engine. It processes TT2-style templates
+// with support for blocks, includes, filters, and virtual methods.
+type Renderer struct {
+    mu             sync.RWMutex
+    includePaths   []fs.FS                                   // filesystems for INCLUDE lookups, searched in order
+    filters        map[string]func(string, ...string) string // text transformation filters
+    virtualMethods map[string]func(any) (any, bool)          // custom virtual methods for variables
+}
+
+// Config holds initialization options for creating a new Renderer.
+type Config struct {
+    IncludePaths []fs.FS                                   // filesystems for template includes (e.g., os.DirFS, embed.FS)
+    Filters      map[string]func(string, ...string) string // custom filters to register
+}
+
+var ErrTemplateNotFound = errors.New("template not found")
+
+// New creates a Renderer with the given config. Registers default filters
+// (upper, lower, html, uri) unless overridden in config.
+func New(config *Config) *Renderer {
+    r := &Renderer{
+        filters:        make(map[string]func(string, ...string) string),
+        virtualMethods: make(map[string]func(any) (any, bool)),
+    }
+
+    if config != nil {
+        r.includePaths = config.IncludePaths
+        if config.Filters != nil {
+            for k, v := range config.Filters {
+                r.filters[k] = v
+            }
+        }
+    }
+
+    // Default filters
+    if r.filters["upper"] == nil {
+        r.filters["upper"] = func(s string, args ...string) string {
+            return strings.ToUpper(s)
+        }
+    }
+    if r.filters["lower"] == nil {
+        r.filters["lower"] = func(s string, args ...string) string {
+            return strings.ToLower(s)
+        }
+    }
+    if r.filters["html"] == nil {
+        r.filters["html"] = func(s string, args ...string) string {
+            return html.EscapeString(s)
+        }
+    }
+    if r.filters["uri"] == nil {
+        r.filters["uri"] = func(s string, args ...string) string {
+            return url.QueryEscape(s)
+        }
+    }
+
+    return r
+}
+
+// AddFilter registers a custom filter function. Returns the Renderer for chaining.
+// Note: This should only be called during initialization, not concurrently.
+func (r *Renderer) AddFilter(name string, fn func(string, ...string) string) *Renderer {
+    r.mu.Lock()
+    defer r.mu.Unlock()
+    r.filters[name] = fn
+    return r
+}
+
+// AddVirtualMethod registers a custom virtual method for variable access.
+// The function receives a value and returns (result, ok).
+// Note: This should only be called during initialization, not concurrently.
+func (r *Renderer) AddVirtualMethod(name string, fn func(any) (any, bool)) *Renderer {
+    r.mu.Lock()
+    defer r.mu.Unlock()
+    r.virtualMethods[name] = fn
+    return r
+}
+
+// getFilter safely retrieves a filter
+func (r *Renderer) getFilter(name string) (func(string, ...string) string, bool) {
+    r.mu.RLock()
+    defer r.mu.RUnlock()
+    fn, ok := r.filters[name]
+    return fn, ok
+}
+
+// getVirtualMethod safely retrieves a virtual method
+func (r *Renderer) getVirtualMethod(name string) (func(any) (any, bool), bool) {
+    r.mu.RLock()
+    defer r.mu.RUnlock()
+    fn, ok := r.virtualMethods[name]
+    return fn, ok
+}
+
+// loadFile attempts to load a template file from the configured filesystems.
+// Searches each fs.FS in IncludePaths order, returning the first match.
+// Returns ErrTemplateNotFound if not found in any filesystem.
+func (r *Renderer) loadFile(name string) (string, error) {
+    r.mu.RLock()
+    paths := r.includePaths
+    r.mu.RUnlock()
+
+    for _, fsys := range paths {
+        data, err := fs.ReadFile(fsys, name)
+        if err == nil {
+            return string(data), nil
+        }
+    }
+    return "", ErrTemplateNotFound
+}
+
+// ProcessFile loads a template file and processes it with the given variables.
+func (r *Renderer) ProcessFile(filename string, vars map[string]any) (string, error) {
+    content, err := r.loadFile(filename)
+    if err != nil {
+        return "", err
+    }
+    return r.Process(content, vars)
+}
+
+// Process processes a template string with the given variables.
+// Uses an AST-based parser and evaluator for template processing.
+func (r *Renderer) Process(input string, vars map[string]any) (string, error) {
+    // Parse the template into an AST
+    parser := NewParser(input)
+    tmpl, parseErrs := parser.Parse()
+    if len(parseErrs) > 0 {
+        return "", parseErrs[0]
+    }
+
+    // Evaluate the AST
+    eval := NewEvaluator(r, vars)
+    return eval.Eval(tmpl)
+}
+
+// Render processes a template file and writes the result to an http.ResponseWriter.
+// Sets Content-Type to text/html and handles 404/500 errors appropriately.
+func (r *Renderer) Render(w http.ResponseWriter, filename string, vars map[string]any) {
+    output, err := r.ProcessFile(filename, vars)
+    if err != nil {
+        if errors.Is(err, ErrTemplateNotFound) {
+            http.Error(w, "404 Not Found", http.StatusNotFound)
+        } else {
+            http.Error(w, "500 Internal Server Error", http.StatusInternalServerError)
+        }
+        return
+    }
+
+    w.Header().Set("Content-Type", "text/html; charset=utf-8")
+    w.WriteHeader(http.StatusOK)
+    w.Write([]byte(output))
+}
+
+// RenderWithStatus processes a template file and writes it with a custom status code.
+func (r *Renderer) RenderWithStatus(w http.ResponseWriter, statusCode int, filename string, vars map[string]any) {
+    output, err := r.ProcessFile(filename, vars)
+    if err != nil {
+        if errors.Is(err, ErrTemplateNotFound) {
+            http.Error(w, "404 Not Found", http.StatusNotFound)
+        } else {
+            http.Error(w, "500 Internal Server Error", http.StatusInternalServerError)
+        }
+        return
+    }
+
+    w.Header().Set("Content-Type", "text/html; charset=utf-8")
+    w.WriteHeader(statusCode)
+    w.Write([]byte(output))
+}
+
+// Render204 writes a 204 No Content response.
+func (r *Renderer) Render204(w http.ResponseWriter) {
+    w.WriteHeader(204)
+    w.Write([]byte(""))
+}
+
+// RenderJSON serializes json_data to JSON and writes it to the http.ResponseWriter.
+// Sets Content-Type to application/json. Returns 500 error on serialization failure.
+func (r *Renderer) RenderJSON(w http.ResponseWriter, json_data any) {
+    data, err := json.Marshal(json_data)
+    if err != nil {
+        http.Error(w, "500 Internal Server Error", http.StatusInternalServerError)
+        return
+    }
+
+    w.Header().Set("Content-Type", "application/json; charset=utf-8")
+    w.WriteHeader(http.StatusOK)
+    w.Write(data)
+}
+
+// RenderJSONWithStatus serializes json_data and writes it with a custom status code.
+func (r *Renderer) RenderJSONWithStatus(w http.ResponseWriter, statusCode int, json_data any) {
+    data, err := json.Marshal(json_data)
+    if err != nil {
+        http.Error(w, "500 Internal Server Error", http.StatusInternalServerError)
+        return
+    }
+
+    w.Header().Set("Content-Type", "application/json; charset=utf-8")
+    w.WriteHeader(statusCode)
+    w.Write(data)
+}

gott_test.go

···
+package gott
+
+import (
+	"testing"
+)
+
+// just a random struct for testing
+type TestUser struct {
+	Handle      string
+	DisplayName string
+	Image       string
+}
+
+// TestNewFeatures tests ELSIF, arithmetic, string concatenation, and map iteration
+func TestNewFeatures(t *testing.T) {
+	r := New(nil)
+
+	tests := []struct {
+		name     string
+		template string
+		vars     map[string]any
+		want     string
+	}{
+		// ELSIF tests
+		{
+			name:     "ELSIF - first branch",
+			template: "[% IF status == 'active' %]active[% ELSIF status == 'pending' %]pending[% ELSE %]other[% END %]",
+			vars:     map[string]any{"status": "active"},
+			want:     "active",
+		},
+		{
+			name:     "ELSIF - second branch",
+			template: "[% IF status == 'active' %]active[% ELSIF status == 'pending' %]pending[% ELSE %]other[% END %]",
+			vars:     map[string]any{"status": "pending"},
+			want:     "pending",
+		},
+		{
+			name:     "ELSIF - else branch",
+			template: "[% IF status == 'active' %]active[% ELSIF status == 'pending' %]pending[% ELSE %]other[% END %]",
+			vars:     map[string]any{"status": "inactive"},
+			want:     "other",
+		},
+		{
+			name:     "ELSIF - multiple elsif",
+			template: "[% IF n == 1 %]one[% ELSIF n == 2 %]two[% ELSIF n == 3 %]three[% ELSE %]many[% END %]",
+			vars:     map[string]any{"n": 3},
+			want:     "three",
+		},
+		// Arithmetic tests
+		{
+			name:     "arithmetic - addition",
+			template: "[% a + b %]",
+			vars:     map[string]any{"a": 3, "b": 4},
+			want:     "7",
+		},
+		{
+			name:     "arithmetic - subtraction",
+			template: "[% a - b %]",
+			vars:     map[string]any{"a": 10, "b": 3},
+			want:     "7",
+		},
+		{
+			name:     "arithmetic - multiplication",
+			template: "[% a * b %]",
+			vars:     map[string]any{"a": 3, "b": 4},
+			want:     "12",
+		},
+		{
+			name:     "arithmetic - division",
+			template: "[% a / b %]",
+			vars:     map[string]any{"a": 12, "b": 4},
+			want:     "3",
+		},
+		{
+			name:     "arithmetic - modulo",
+			template: "[% a % b %]",
+			vars:     map[string]any{"a": 10, "b": 3},
+			want:     "1",
+		},
+		{
+			name:     "arithmetic - complex expression",
+			template: "[% (a + b) * c %]",
+			vars:     map[string]any{"a": 2, "b": 3, "c": 4},
+			want:     "20",
+		},
+		{
+			name:     "arithmetic - in condition",
+			template: "[% IF count + 1 > 5 %]yes[% END %]",
+			vars:     map[string]any{"count": 5},
+			want:     "yes",
+		},
+		// String concatenation tests
+		{
+			name:     "string concat - two strings",
+			template: "[% a + b %]",
+			vars:     map[string]any{"a": "hello", "b": "world"},
+			want:     "helloworld",
+		},
+		{
+			name:     "string concat - string and literal",
+			template: `[% name + "-suffix" %]`,
+			vars:     map[string]any{"name": "test"},
+			want:     "test-suffix",
+		},
+		{
+			name:     "string concat - number to string",
+			template: `[% "version-" + version %]`,
+			vars:     map[string]any{"version": 3},
+			want:     "version-3",
+		},
+		{
+			name:     "string concat - in condition",
+			template: `[% IF name + "-dev" == "test-dev" %]match[% END %]`,
+			vars:     map[string]any{"name": "test"},
+			want:     "match",
+		},
+		{
+			name:     "string concat - chained",
+			template: `[% "Hello, " + name + "!" %]`,
+			vars:     map[string]any{"name": "World"},
+			want:     "Hello, World!",
+		},
+		// String quote styles
+		{
+			name:     "single quotes in comparison",
+			template: "[% IF status == 'active' %]yes[% END %]",
+			vars:     map[string]any{"status": "active"},
+			want:     "yes",
+		},
+		{
+			name:     "double quotes in comparison",
+			template: `[% IF status == "active" %]yes[% END %]`,
+			vars:     map[string]any{"status": "active"},
+			want:     "yes",
+		},
+		// Map iteration tests
+		{
+			name:     "map iteration - key and value",
+			template: "[% FOREACH entry IN config %][% entry.key %]=[% entry.value %];[% END %]",
+			vars:     map[string]any{"config": map[string]any{"host": "localhost", "port": 8080}},
+			want:     "host=localhost;port=8080;",
+		},
+		{
+			name:     "map iteration - sorted by key",
+			template: "[% FOREACH e IN data %][% e.key %][% END %]",
+			vars:     map[string]any{"data": map[string]any{"c": 3, "a": 1, "b": 2}},
+			want:     "abc",
+		},
+		// SET directive tests
+		{
+			name:     "SET - simple assignment",
+			template: "[% SET x = 42 %][% x %]",
+			vars:     map[string]any{},
+			want:     "42",
+		},
+		{
+			name:     "SET - string assignment",
+			template: `[% SET greeting = "Hello" %][% greeting %]`,
+			vars:     map[string]any{},
+			want:     "Hello",
+		},
+		{
+			name:     "SET - expression",
+			template: "[% SET total = a + b %][% total %]",
+			vars:     map[string]any{"a": 10, "b": 5},
+			want:     "15",
+		},
+		{
+			name:     "SET - use in condition",
+			template: "[% SET threshold = 10 %][% IF count > threshold %]high[% ELSE %]low[% END %]",
+			vars:     map[string]any{"count": 15},
+			want:     "high",
+		},
+		// Default value tests
+		{
+			name:     "default - with undefined var",
+			template: `[% name || "guest" %]`,
+			vars:     map[string]any{},
+			want:     "guest",
+		},
+		{
+			name:     "default - with defined var",
+			template: `[% name || "guest" %]`,
+			vars:     map[string]any{"name": "alice"},
+			want:     "alice",
+		},
+		// Filter tests
+		{
+			name:     "filter - upper",
+			template: "[% name | upper %]",
+			vars:     map[string]any{"name": "hello"},
+			want:     "HELLO",
+		},
+		{
+			name:     "filter - chain",
+			template: "[% text | lower | upper %]",
+			vars:     map[string]any{"text": "Hello"},
+			want:     "HELLO",
+		},
+		// FOREACH with slice
+		{
+			name:     "foreach - slice",
+			template: "[% FOREACH item IN items %][% item %],[% END %]",
+			vars:     map[string]any{"items": []string{"a", "b", "c"}},
+			want:     "a,b,c,",
+		},
+		// Virtual methods
+		{
+			name:     "vmethod - length",
+			template: "[% items.length %]",
+			vars:     map[string]any{"items": []int{1, 2, 3, 4, 5}},
+			want:     "5",
+		},
+		{
+			name:     "vmethod - first",
+			template: "[% items.first %]",
+			vars:     map[string]any{"items": []string{"a", "b", "c"}},
+			want:     "a",
+		},
+		{
+			name:     "vmethod - last",
+			template: "[% items.last %]",
+			vars:     map[string]any{"items": []string{"a", "b", "c"}},
+			want:     "c",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := r.Process(tt.template, tt.vars)
+			if err != nil {
+				t.Fatalf("Process() error = %v", err)
+			}
+			if got != tt.want {
+				t.Errorf("Process() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestSimpleIfCondition(t *testing.T) {
+	r := New(nil)
+	
+	tests := []struct {
+		name     string
+		template string
+		vars     map[string]any
+		want     string
+	}{
+		{
+			name:     "simple IF true",
+			template: "[% IF user %]yes[% END %]",
+			vars:     map[string]any{"user": "test"},
+			want:     "yes",
+		},
+		{
+			name:     "simple IF false - missing var",
+			template: "[% IF user %]yes[% END %]",
+			vars:     map[string]any{},
+			want:     "",
+		},
+		{
+			name:     "IF with defined",
+			template: "[% IF user.defined %]yes[% END %]",
+			vars:     map[string]any{"user": "test"},
+			want:     "yes",
+		},
+		{
+			name:     "IF with nested defined",
+			template: "[% IF user.Image.defined %]yes[% END %]",
+			vars:     map[string]any{"user": map[string]any{"Image": "http://example.com/img.jpg"}},
+			want:     "yes",
+		},
+		{
+			name:     "IF with AND - both true",
+			template: "[% IF a && b %]yes[% END %]",
+			vars:     map[string]any{"a": true, "b": true},
+			want:     "yes",
+		},
+		{
+			name:     "IF with AND - one false",
+			template: "[% IF a && b %]yes[% END %]",
+			vars:     map[string]any{"a": true, "b": false},
+			want:     "",
+		},
+		{
+			name:     "IF with OR - both true",
+			template: "[% IF a || b %]yes[% END %]",
+			vars:     map[string]any{"a": true, "b": true},
+			want:     "yes",
+		},
+		{
+			name:     "IF with OR - one true",
+			template: "[% IF a || b %]yes[% END %]",
+			vars:     map[string]any{"a": false, "b": true},
+			want:     "yes",
+		},
+		{
+			name:     "IF with struct user",
+			template: "[% IF user %]yes[% END %]",
+			vars:     map[string]any{"user": TestUser{Handle: "test"}},
+			want:     "yes",
+		},
+		{
+			name:     "IF with struct Image.defined",
+			template: "[% IF user.Image.defined %]yes[% END %]",
+			vars:     map[string]any{"user": TestUser{Image: "http://example.com/img.jpg"}},
+			want:     "yes",
+		},
+		{
+			name:     "IF with struct Image.defined - empty",
+			template: "[% IF user.Image.defined %]yes[% END %]",
+			vars:     map[string]any{"user": TestUser{}},
+			want:     "",
+		},
+		// Comparison operators
+		{
+			name:     "IF greater than - true",
+			template: "[% IF count > 0 %]yes[% END %]",
+			vars:     map[string]any{"count": 5},
+			want:     "yes",
+		},
+		{
+			name:     "IF greater than - false",
+			template: "[% IF count > 0 %]yes[% END %]",
+			vars:     map[string]any{"count": 0},
+			want:     "",
+		},
+		{
+			name:     "IF equals string",
+			template: "[% IF status == 'active' %]yes[% END %]",
+			vars:     map[string]any{"status": "active"},
+			want:     "yes",
+		},
+		{
+			name:     "IF equals string - false",
+			template: "[% IF status == 'active' %]yes[% END %]",
+			vars:     map[string]any{"status": "inactive"},
+			want:     "",
+		},
+		{
+			name:     "IF not equals",
+			template: "[% IF status != 'error' %]yes[% END %]",
+			vars:     map[string]any{"status": "ok"},
+			want:     "yes",
+		},
+		{
+			name:     "IF greater than or equal",
+			template: "[% IF count >= 5 %]yes[% END %]",
+			vars:     map[string]any{"count": 5},
+			want:     "yes",
+		},
+		{
+			name:     "IF less than",
+			template: "[% IF count < 10 %]yes[% END %]",
+			vars:     map[string]any{"count": 5},
+			want:     "yes",
+		},
+		{
+			name:     "IF combined AND with comparison",
+			template: "[% IF enabled && count > 0 %]yes[% END %]",
+			vars:     map[string]any{"enabled": true, "count": 5},
+			want:     "yes",
+		},
+		{
+			name:     "nested IF with defined",
+			template: "[% IF user.defined %]outer[% IF user.Image.defined %]inner[% END %][% END %]",
+			vars:     map[string]any{"user": map[string]any{"Image": "test.jpg"}},
+			want:     "outerinner",
+		},
+		{
+			name:     "IF with ELSE",
+			template: "[% IF user.Image.defined %]has-image[% ELSE %]no-image[% END %]",
+			vars:     map[string]any{"user": map[string]any{"Image": ""}},
+			want:     "no-image",
+		},
+		{
+			name: "multiline nested IF like user_detail",
+			template: `<div>
+    [% IF user.defined %]
+    <div class="outer">
+        [% IF user.Image.defined %]
+            <img src="[% user.Image %]">
+        [% ELSE %]
+            <div>placeholder</div>
+        [% END %]
+    </div>
+    [% END %]
+</div>`,
+			vars: map[string]any{"user": map[string]any{"Image": "test.jpg"}},
+			want: "<div>\n    \n    <div class=\"outer\">\n        \n            <img src=\"test.jpg\">\n        \n    </div>\n    \n</div>",
+		},
+	}
+	
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := r.Process(tt.template, tt.vars)
+			if err != nil {
+				t.Fatalf("Process() error = %v", err)
+			}
+			if got != tt.want {
+				t.Errorf("Process() = %q, want %q", got, tt.want)
+				if tt.name == "multiline nested IF like user_detail" {
+					t.Logf("Template:\n%s", tt.template)
+					t.Logf("Result:\n%s", got)
+				}
+			}
+		})
+	}
+}

lexer.go

···
+package gott
+
+import (
+    "strings"
+    "unicode"
+    "unicode/utf8"
+)
+
+const eof = -1
+
+// Lexer tokenizes a template string into a sequence of tokens
+type Lexer struct {
+    input   string     // the string being scanned
+    start   int        // start position of current token
+    pos     int        // current position in input
+    width   int        // width of last rune read
+    line    int        // current line number (1-based)
+    linePos int        // position of start of current line
+    tokens  chan Token // channel of scanned tokens
+}
+
+// stateFn represents a lexer state function; returns the next state
+type stateFn func(*Lexer) stateFn
+
+// NewLexer creates a new lexer for the given input and starts scanning
+func NewLexer(input string) *Lexer {
+    l := &Lexer{
+        input:   input,
+        line:    1,
+        linePos: 0,
+        tokens:  make(chan Token, 2),
+    }
+    go l.run()
+    return l
+}
+
+// run executes the state machine
+func (l *Lexer) run() {
+    for state := lexText; state != nil; {
+        state = state(l)
+    }
+    close(l.tokens)
+}
+
+// NextToken returns the next token from the lexer
+func (l *Lexer) NextToken() Token {
+    return <-l.tokens
+}
+
+// Tokens returns all tokens as a slice (consumes the channel)
+func (l *Lexer) Tokens() []Token {
+    var tokens []Token
+    for tok := range l.tokens {
+        tokens = append(tokens, tok)
+    }
+    return tokens
+}
+
+// emit sends a token to the tokens channel
+func (l *Lexer) emit(t TokenType) {
+    l.tokens <- Token{
+        Type:  t,
+        Value: l.input[l.start:l.pos],
+        Pos:   l.currentPos(),
+    }
+    l.start = l.pos
+}
+
+// emitValue sends a token with a specific value
+func (l *Lexer) emitValue(t TokenType, value string) {
+    l.tokens <- Token{
+        Type:  t,
+        Value: value,
+        Pos:   l.currentPos(),
+    }
+    l.start = l.pos
+}
+
+// currentPos returns the current position for error reporting
+func (l *Lexer) currentPos() Position {
+    return Position{
+        Line:   l.line,
+        Column: l.start - l.linePos + 1,
+        Offset: l.start,
+    }
+}
+
+// next returns the next rune in the input and advances the position
+func (l *Lexer) next() rune {
+    if l.pos >= len(l.input) {
+        l.width = 0
+        return eof
+    }
+    r, w := utf8.DecodeRuneInString(l.input[l.pos:])
+    l.width = w
+    l.pos += l.width
+    if r == '\n' {
+        l.line++
+        l.linePos = l.pos
+    }
+    return r
+}
+
+// backup steps back one rune (can only be called once per next call)
+func (l *Lexer) backup() {
+    l.pos -= l.width
+    // If we backed up over a newline, decrement line count
+    if l.pos < len(l.input) && l.input[l.pos] == '\n' {
+        l.line--
+        // Find previous line start
+        l.linePos = strings.LastIndex(l.input[:l.pos], "\n") + 1
+    }
+}
+
+// peek returns the next rune without advancing
+func (l *Lexer) peek() rune {
+    r := l.next()
+    l.backup()
+    return r
+}
+
+// ignore skips over the pending input
+func (l *Lexer) ignore() {
+    l.start = l.pos
+}
+
+// errorf emits an error token and terminates scanning
+func (l *Lexer) errorf(format string, args ...any) stateFn {
+    l.tokens <- Token{
+        Type:  TokenError,
+        Value: sprintf(format, args...),
+        Pos:   l.currentPos(),
+    }
+    return nil
+}
+
+// sprintf is a simple formatter (avoiding fmt import in hot path)
+func sprintf(format string, args ...any) string {
+    // Simple implementation - for errors only
+    result := format
+    for _, arg := range args {
+        if s, ok := arg.(string); ok {
+            result = strings.Replace(result, "%s", s, 1)
+            result = strings.Replace(result, "%q", "'"+s+"'", 1)
+        }
+    }
+    return result
+}
+
+// skipWhitespace advances past any whitespace characters
+func (l *Lexer) skipWhitespace() {
+    for {
+        r := l.next()
+        if r == eof || !unicode.IsSpace(r) {
+            l.backup()
+            break
+        }
+    }
+    l.ignore()
+}
+
+// hasPrefix checks if the remaining input starts with the given prefix
+func (l *Lexer) hasPrefix(prefix string) bool {
+    return strings.HasPrefix(l.input[l.pos:], prefix)
+}
+
+// ---- State Functions ----
+
+// lexText scans text outside of tags until [% or EOF
+func lexText(l *Lexer) stateFn {
+    for {
+        if l.hasPrefix("[%") {
+            if l.pos > l.start {
+                l.emit(TokenText)
+            }
+            return lexTagOpen
+        }
+        if l.next() == eof {
+            break
+        }
+    }
+    // Emit any remaining text
+    if l.pos > l.start {
+        l.emit(TokenText)
+    }
+    l.emit(TokenEOF)
+    return nil
+}
+
+// lexTagOpen scans the [% opening delimiter
+func lexTagOpen(l *Lexer) stateFn {
+    l.pos += 2 // skip [%
+    l.emit(TokenTagOpen)
+    return lexInsideTag
+}
+
+// lexInsideTag scans inside a [% ... %] tag
+func lexInsideTag(l *Lexer) stateFn {
+    l.skipWhitespace()
+
+    // Check for closing tag
+    if l.hasPrefix("%]") {
+        l.pos += 2
+        l.emit(TokenTagClose)
+        return lexText
+    }
+
+    // Check for two-character operators first
+    twoCharOps := []struct {
+        str string
+        tok TokenType
+    }{
+        {"==", TokenEq},
+        {"!=", TokenNe},
+        {">=", TokenGe},
+        {"<=", TokenLe},
+        {"&&", TokenAnd},
+        {"||", TokenOr},
+    }
+    for _, op := range twoCharOps {
+        if l.hasPrefix(op.str) {
+            l.pos += 2
+            l.emit(op.tok)
+            return lexInsideTag
+        }
+    }
+
+    // Check for single-character operators/delimiters
+    r := l.next()
+    switch r {
+    case eof:
+        return l.errorf("unclosed tag")
+    case '>':
+        l.emit(TokenGt)
+        return lexInsideTag
+    case '<':
+        l.emit(TokenLt)
+        return lexInsideTag
+    case '+':
+        l.emit(TokenPlus)
+        return lexInsideTag
+    case '-':
+        // Could be minus or negative number
+        if unicode.IsDigit(l.peek()) {
+            l.backup()
+            return lexNumber
+        }
+        l.emit(TokenMinus)
+        return lexInsideTag
+    case '*':
+        l.emit(TokenMul)
+        return lexInsideTag
+    case '/':
+        l.emit(TokenDiv)
+        return lexInsideTag
+    case '%':
+        // Check if this is %] (tag close) or % (modulo)
+        if l.peek() == ']' {
+            l.backup()
+            l.pos += 2
+            l.emit(TokenTagClose)
+            return lexText
+        }
+        l.emit(TokenMod)
+        return lexInsideTag
+    case '.':
+        l.emit(TokenDot)
+        return lexInsideTag
+    case '|':
+        l.emit(TokenPipe)
+        return lexInsideTag
+    case '(':
+        l.emit(TokenLParen)
+        return lexInsideTag
+    case ')':
+        l.emit(TokenRParen)
+        return lexInsideTag
+    case ',':
+        l.emit(TokenComma)
+        return lexInsideTag
+    case '=':
+        l.emit(TokenAssign)
+        return lexInsideTag
+    case '"', '\'':
+        l.backup()
+        return lexString
+    }
+
+    // Check for number
+    if unicode.IsDigit(r) {
+        l.backup()
+        return lexNumber
+    }
+
+    // Must be identifier or keyword
+    if isAlpha(r) || r == '_' {
+        l.backup()
+        return lexIdentifier
+    }
+
+    return l.errorf("unexpected character: %s", string(r))
+}
+
+// lexString scans a quoted string literal (single or double quotes)
+func lexString(l *Lexer) stateFn {
+    quote := l.next() // consume opening quote
+    l.ignore()        // don't include quote in value
+
+    for {
+        r := l.next()
+        if r == eof {
+            return l.errorf("unterminated string")
+        }
+        if r == '\\' {
+            // Skip escaped character
+            l.next()
+            continue
+        }
+        if r == quote {
+            // Don't include closing quote in value
+            l.backup()
+            l.emit(TokenString)
+            l.next() // consume closing quote
+            l.ignore()
+            return lexInsideTag
+        }
+    }
+}
+
+// lexNumber scans a number (integer or float, possibly negative)
+func lexNumber(l *Lexer) stateFn {
+    // Optional leading minus
+    if l.peek() == '-' {
+        l.next()
+    }
+
+    // Integer part
+    digits := false
+    for unicode.IsDigit(l.peek()) {
+        l.next()
+        digits = true
+    }
+
+    if !digits {
+        return l.errorf("expected digits in number")
+    }
+
+    // Optional decimal part
+    if l.peek() == '.' {
+        l.next()
+        for unicode.IsDigit(l.peek()) {
+            l.next()
+        }
+    }
+
+    l.emit(TokenNumber)
+    return lexInsideTag
+}
+
+// lexIdentifier scans an identifier or keyword
+func lexIdentifier(l *Lexer) stateFn {
+    for {
+        r := l.next()
+        if !isAlphaNumeric(r) && r != '_' {
+            l.backup()
+            break
+        }
+    }
+
+    word := l.input[l.start:l.pos]
+    tokType := LookupKeyword(word)
+    l.emit(tokType)
+    return lexInsideTag
+}
+
+// isAlpha returns true if r is an alphabetic character
+func isAlpha(r rune) bool {
+    return unicode.IsLetter(r)
+}
+
+// isAlphaNumeric returns true if r is alphanumeric
+func isAlphaNumeric(r rune) bool {
+    return unicode.IsLetter(r) || unicode.IsDigit(r)
+}

parser.go

···
+package gott
+
+import (
+    "strconv"
+)
+
+// Parser parses a token stream into an AST
+type Parser struct {
+    lexer     *Lexer
+    token     Token   // current token
+    peekToken Token   // lookahead token
+    errors    []error // accumulated parse errors
+}
+
+// NewParser creates a new parser for the given input
+func NewParser(input string) *Parser {
+    p := &Parser{
+        lexer: NewLexer(input),
+    }
+    // Load first two tokens
+    p.advance()
+    p.advance()
+    return p
+}
+
+// advance moves to the next token
+func (p *Parser) advance() {
+    p.token = p.peekToken
+    p.peekToken = p.lexer.NextToken()
+}
+
+// expect checks that the current token is of the expected type and advances
+func (p *Parser) expect(t TokenType) bool {
+    if p.token.Type != t {
+        p.errorf("expected %s, got %s", t, p.token.Type)
+        return false
+    }
+    p.advance()
+    return true
+}
+
+// errorf records a parse error
+func (p *Parser) errorf(format string, args ...any) {
+    err := &ParseError{
+        Pos:     p.token.Pos,
+        Message: sprintf(format, args...),
+    }
+    p.errors = append(p.errors, err)
+}
+
+// Parse parses the input and returns the AST
+func (p *Parser) Parse() (*Template, []error) {
+    t := &Template{
+        Position: Position{Line: 1, Column: 1, Offset: 0},
+        Nodes:    []Node{},
+    }
+
+    for p.token.Type != TokenEOF && p.token.Type != TokenError {
+        node := p.parseNode()
+        if node != nil {
+            t.Nodes = append(t.Nodes, node)
+        }
+    }
+
+    if p.token.Type == TokenError {
+        p.errors = append(p.errors, &ParseError{
+            Pos:     p.token.Pos,
+            Message: p.token.Value,
+        })
+    }
+
+    return t, p.errors
+}
+
+// parseNode parses a single node (text or tag)
+func (p *Parser) parseNode() Node {
+    switch p.token.Type {
+    case TokenText:
+        return p.parseText()
+    case TokenTagOpen:
+        return p.parseTag()
+    default:
+        p.errorf("unexpected token: %s", p.token.Type)
+        p.advance()
+        return nil
+    }
+}
+
+// parseText parses a text node
+func (p *Parser) parseText() Node {
+    node := &TextNode{
+        Position: p.token.Pos,
+        Text:     p.token.Value,
+    }
+    p.advance()
+    return node
+}
+
+// parseTag parses a [% ... %] tag
+func (p *Parser) parseTag() Node {
+    p.expect(TokenTagOpen)
+
+    switch p.token.Type {
+    case TokenIF:
+        return p.parseIf()
+    case TokenUNLESS:
+        return p.parseUnless()
+    case TokenFOREACH:
+        return p.parseForeach()
+    case TokenBLOCK:
+        return p.parseBlock()
+    case TokenINCLUDE:
+        return p.parseInclude()
+    case TokenWRAPPER:
+        return p.parseWrapper()
+    case TokenSET:
+        return p.parseSet()
+    default:
+        // Expression output: [% expr %]
+        return p.parseOutput()
+    }
+}
+
+// parseIf parses an IF statement with optional ELSIF and ELSE
+func (p *Parser) parseIf() *IfStmt {
+    pos := p.token.Pos
+    p.expect(TokenIF)
+
+    cond := p.parseExpr()
+    if !p.expect(TokenTagClose) {
+        return nil
+    }
+
+    stmt := &IfStmt{
+        Position:  pos,
+        Condition: cond,
+    }
+
+    // Parse body until ELSIF, ELSE, or END
+    stmt.Body = p.parseBody(TokenELSIF, TokenELSE, TokenEND)
+
+    // Parse ELSIF chain
+    for p.token.Type == TokenTagOpen && p.peekToken.Type == TokenELSIF {
+        p.expect(TokenTagOpen)
+        elsifPos := p.token.Pos
+        p.expect(TokenELSIF)
+
+        elsifCond := p.parseExpr()
+        if !p.expect(TokenTagClose) {
+            return nil
+        }
+
+        elsifBody := p.parseBody(TokenELSIF, TokenELSE, TokenEND)
+
+        stmt.ElsIf = append(stmt.ElsIf, &ElsIfClause{
+            Position:  elsifPos,
+            Condition: elsifCond,
+            Body:      elsifBody,
+        })
+    }
+
+    // Parse optional ELSE
+    if p.token.Type == TokenTagOpen && p.peekToken.Type == TokenELSE {
+        p.expect(TokenTagOpen)
+        p.expect(TokenELSE)
+        p.expect(TokenTagClose)
+        stmt.Else = p.parseBody(TokenEND)
+    }
+
+    // Expect END
+    p.expectEndTag()
+
+    return stmt
+}
+
+// parseUnless parses an UNLESS statement
+func (p *Parser) parseUnless() *UnlessStmt {
+    pos := p.token.Pos
+    p.expect(TokenUNLESS)
+
+    cond := p.parseExpr()
+    if !p.expect(TokenTagClose) {
+        return nil
+    }
+
+    stmt := &UnlessStmt{
+        Position:  pos,
+        Condition: cond,
+    }
+
+    stmt.Body = p.parseBody(TokenELSE, TokenEND)
+
+    // Parse optional ELSE
+    if p.token.Type == TokenTagOpen && p.peekToken.Type == TokenELSE {
+        p.expect(TokenTagOpen)
+        p.expect(TokenELSE)
+        p.expect(TokenTagClose)
+        stmt.Else = p.parseBody(TokenEND)
+    }
+
+    p.expectEndTag()
+
+    return stmt
+}
+
+// parseForeach parses a FOREACH loop
+func (p *Parser) parseForeach() *ForeachStmt {
+    pos := p.token.Pos
+    p.expect(TokenFOREACH)
+
+    if p.token.Type != TokenIdent {
+        p.errorf("expected identifier, got %s", p.token.Type)
+        return nil
+    }
+    itemVar := p.token.Value
+    p.advance()
+
+    if !p.expect(TokenIN) {
+        return nil
+    }
+
+    listExpr := p.parseExpr()
+    if !p.expect(TokenTagClose) {
+        return nil
+    }
+
+    body := p.parseBody(TokenEND)
+    p.expectEndTag()
+
+    return &ForeachStmt{
+        Position: pos,
+        ItemVar:  itemVar,
+        ListExpr: listExpr,
+        Body:     body,
+    }
+}
+
+// parseBlock parses a BLOCK definition
+func (p *Parser) parseBlock() *BlockStmt {
+    pos := p.token.Pos
+    p.expect(TokenBLOCK)
+
+    if p.token.Type != TokenIdent {
+        p.errorf("expected block name, got %s", p.token.Type)
+        return nil
+    }
+    name := p.token.Value
+    p.advance()
+
+    if !p.expect(TokenTagClose) {
+        return nil
+    }
+
+    body := p.parseBody(TokenEND)
+    p.expectEndTag()
+
+    return &BlockStmt{
+        Position: pos,
+        Name:     name,
+        Body:     body,
+    }
+}
+
+// parseInclude parses an INCLUDE directive
+func (p *Parser) parseInclude() *IncludeStmt {
+    pos := p.token.Pos
+    p.expect(TokenINCLUDE)
+
+    var name string
+    if p.token.Type == TokenString {
+        name = p.token.Value
+        p.advance()
+    } else if p.token.Type == TokenIdent {
+        // Could be a simple name or a path like "partials/header"
+        name = p.token.Value
+        p.advance()
+        // Handle path-like includes: partials/header.html
+        for p.token.Type == TokenDiv || p.token.Type == TokenDot {
+            name += p.token.Value
+            p.advance()
+            if p.token.Type == TokenIdent {
+                name += p.token.Value
+                p.advance()
+            }
+        }
+    } else {
+        p.errorf("expected include name, got %s", p.token.Type)
+        return nil
+    }
+
+    p.expect(TokenTagClose)
+
+    return &IncludeStmt{
+        Position: pos,
+        Name:     name,
+    }
+}
+
+// parseWrapper parses a WRAPPER directive
+func (p *Parser) parseWrapper() *WrapperStmt {
+    pos := p.token.Pos
+    p.expect(TokenWRAPPER)
+
+    var name string
+    if p.token.Type == TokenString {
+        name = p.token.Value
+        p.advance()
+    } else if p.token.Type == TokenIdent {
+        name = p.token.Value
+        p.advance()
+        // Handle path-like wrappers
+        for p.token.Type == TokenDiv || p.token.Type == TokenDot {
+            name += p.token.Value
+            p.advance()
+            if p.token.Type == TokenIdent {
+                name += p.token.Value
+                p.advance()
+            }
+        }
+    } else {
+        p.errorf("expected wrapper name, got %s", p.token.Type)
+        return nil
+    }
+
+    if !p.expect(TokenTagClose) {
+        return nil
+    }
+
+    content := p.parseBody(TokenEND)
+    p.expectEndTag()
+
+    return &WrapperStmt{
+        Position: pos,
+        Name:     name,
+        Content:  content,
+    }
+}
+
+// parseSet parses a SET directive
+func (p *Parser) parseSet() *SetStmt {
+    pos := p.token.Pos
+    p.expect(TokenSET)
+
+    if p.token.Type != TokenIdent {
+        p.errorf("expected variable name, got %s", p.token.Type)
+        return nil
+    }
+    varName := p.token.Value
+    p.advance()
+
+    if !p.expect(TokenAssign) {
+        return nil
+    }
+
+    value := p.parseExpr()
+    p.expect(TokenTagClose)
+
+    return &SetStmt{
+        Position: pos,
+        Var:      varName,
+        Value:    value,
+    }
+}
+
+// parseOutput parses an expression output: [% expr %]
+func (p *Parser) parseOutput() *OutputStmt {
+    pos := p.token.Pos
+    expr := p.parseExpr()
+    p.expect(TokenTagClose)
+
+    return &OutputStmt{
+        Position: pos,
+        Expr:     expr,
+    }
+}
+
+// parseBody parses nodes until one of the stop tokens is seen as the next keyword
+func (p *Parser) parseBody(stopTokens ...TokenType) []Node {
+    var nodes []Node
+
+    for {
+        // Check for EOF
+        if p.token.Type == TokenEOF {
+            break
+        }
+
+        // Check if next tag starts with a stop token
+        if p.token.Type == TokenTagOpen {
+            for _, stop := range stopTokens {
+                if p.peekToken.Type == stop {
+                    return nodes
+                }
+            }
+        }
+
+        node := p.parseNode()
+        if node != nil {
+            nodes = append(nodes, node)
+        }
+    }
+
+    return nodes
+}
+
+// expectEndTag expects [% END %]
+func (p *Parser) expectEndTag() {
+    if p.token.Type == TokenTagOpen && p.peekToken.Type == TokenEND {
+        p.expect(TokenTagOpen)
+        p.expect(TokenEND)
+        p.expect(TokenTagClose)
+    } else {
+        p.errorf("expected [%% END %%], got %s", p.token.Type)
+    }
+}
+
+// ---- Expression Parsing (with precedence) ----
+
+// parseExpr is the entry point for expression parsing
+func (p *Parser) parseExpr() Expr {
+    return p.parseOr()
+}
+
+// parseOr handles || (logical OR) and || (default value)
+// When || is followed by a literal and left is an identifier/filter expr, treat as default
+func (p *Parser) parseOr() Expr {
+    left := p.parseAnd()
+
+    for p.token.Type == TokenOr {
+        pos := p.token.Pos
+        p.advance()
+        right := p.parseAnd()
+
+        // Check if this looks like a default value expression:
+        // left is identifier/filter, right is a literal
+        if isDefaultCandidate(left) && isLiteralExpr(right) {
+            left = &DefaultExpr{
+                Position: pos,
+                Expr:     left,
+                Default:  right,
+            }
+        } else {
+            left = &BinaryExpr{
+                Position: pos,
+                Op:       TokenOr,
+                Left:     left,
+                Right:    right,
+            }
+        }
+    }
+
+    return left
+}
+
+// isDefaultCandidate returns true if the expression can have a default value
+func isDefaultCandidate(e Expr) bool {
+    switch e.(type) {
+    case *IdentExpr, *FilterExpr:
+        return true
+    }
+    return false
+}
+
+// isLiteralExpr returns true if the expression is a literal
+func isLiteralExpr(e Expr) bool {
+    _, ok := e.(*LiteralExpr)
+    return ok
+}
+
+// parseAnd handles && (logical AND)
+func (p *Parser) parseAnd() Expr {
+    left := p.parseComparison()
+
+    for p.token.Type == TokenAnd {
+        op := p.token.Type
+        pos := p.token.Pos
+        p.advance()
+        right := p.parseComparison()
+        left = &BinaryExpr{
+            Position: pos,
+            Op:       op,
+            Left:     left,
+            Right:    right,
+        }
+    }
+
+    return left
+}
+
+// parseComparison handles ==, !=, <, <=, >, >=
+func (p *Parser) parseComparison() Expr {
+    left := p.parseAdditive()
+
+    if isComparisonOp(p.token.Type) {
+        op := p.token.Type
+        pos := p.token.Pos
+        p.advance()
+        right := p.parseAdditive()
+        return &BinaryExpr{
+            Position: pos,
+            Op:       op,
+            Left:     left,
+            Right:    right,
+        }
+    }
+
+    return left
+}
+
+// parseAdditive handles + and -
+func (p *Parser) parseAdditive() Expr {
+    left := p.parseMultiplicative()
+
+    for p.token.Type == TokenPlus || p.token.Type == TokenMinus {
+        op := p.token.Type
+        pos := p.token.Pos
+        p.advance()
+        right := p.parseMultiplicative()
+        left = &BinaryExpr{
+            Position: pos,
+            Op:       op,
+            Left:     left,
+            Right:    right,
+        }
+    }
+
+    return left
+}
+
+// parseMultiplicative handles *, /, %
+func (p *Parser) parseMultiplicative() Expr {
+    left := p.parseUnary()
+
+    for p.token.Type == TokenMul || p.token.Type == TokenDiv || p.token.Type == TokenMod {
+        op := p.token.Type
+        pos := p.token.Pos
+        p.advance()
+        right := p.parseUnary()
+        left = &BinaryExpr{
+            Position: pos,
+            Op:       op,
+            Left:     left,
+            Right:    right,
+        }
+    }
+
+    return left
+}
+
+// parseUnary handles unary - (negation)
+func (p *Parser) parseUnary() Expr {
+    if p.token.Type == TokenMinus {
+        pos := p.token.Pos
+        p.advance()
+        return &UnaryExpr{
+            Position: pos,
+            Op:       TokenMinus,
+            X:        p.parseUnary(),
+        }
+    }
+    return p.parsePrimary()
+}
+
+// parsePrimary handles literals, identifiers, function calls, and parentheses
+func (p *Parser) parsePrimary() Expr {
+    switch p.token.Type {
+    case TokenNumber:
+        val, _ := strconv.ParseFloat(p.token.Value, 64)
+        expr := &LiteralExpr{
+            Position: p.token.Pos,
+            Value:    val,
+        }
+        p.advance()
+        return expr
+
+    case TokenString:
+        expr := &LiteralExpr{
+            Position: p.token.Pos,
+            Value:    p.token.Value,
+        }
+        p.advance()
+        return expr
+
+    case TokenIdent:
+        return p.parseIdentOrCall()
+
+    case TokenLParen:
+        p.advance()
+        expr := p.parseExpr()
+        p.expect(TokenRParen)
+        return expr
+    }
+
+    p.errorf("unexpected token in expression: %s", p.token.Type)
+    return &LiteralExpr{Position: p.token.Pos, Value: ""}
+}
+
+// parseIdentOrCall parses an identifier, possibly with dots, function calls, or filters
+func (p *Parser) parseIdentOrCall() Expr {
+    pos := p.token.Pos
+
+    // Collect dot-separated parts: foo.bar.baz
+    parts := []string{p.token.Value}
+    p.advance()
+
+    for p.token.Type == TokenDot {
+        p.advance()
+        if p.token.Type != TokenIdent {
+            p.errorf("expected identifier after '.', got %s", p.token.Type)
+            break
+        }
+        parts = append(parts, p.token.Value)
+        p.advance()
+    }
+
+    var expr Expr = &IdentExpr{
+        Position: pos,
+        Parts:    parts,
+    }
+
+    // Check for function call: func(args)
+    if p.token.Type == TokenLParen && len(parts) == 1 {
+        p.advance()
+        args := p.parseArgList()
+        p.expect(TokenRParen)
+        expr = &CallExpr{
+            Position: pos,
+            Func:     parts[0],
+            Args:     args,
+        }
+    }
+
+    // Check for filter chain: expr | filter | filter(args)
+    for p.token.Type == TokenPipe {
+        p.advance()
+        if p.token.Type != TokenIdent {
+            p.errorf("expected filter name after '|', got %s", p.token.Type)
+            break
+        }
+        filterName := p.token.Value
+        filterPos := p.token.Pos
+        p.advance()
+
+        var filterArgs []Expr
+        if p.token.Type == TokenLParen {
+            p.advance()
+            filterArgs = p.parseArgList()
+            p.expect(TokenRParen)
+        }
+
+        expr = &FilterExpr{
+            Position: filterPos,
+            Input:    expr,
+            Filter:   filterName,
+            Args:     filterArgs,
+        }
+    }
+
+    return expr
+}
+
+// parseArgList parses a comma-separated list of expressions
+func (p *Parser) parseArgList() []Expr {
+    var args []Expr
+
+    if p.token.Type == TokenRParen {
+        return args
+    }
+
+    args = append(args, p.parseExpr())
+
+    for p.token.Type == TokenComma {
+        p.advance()
+        args = append(args, p.parseExpr())
+    }
+
+    return args
+}
+
+// isComparisonOp returns true if the token is a comparison operator
+func isComparisonOp(t TokenType) bool {
+    switch t {
+    case TokenEq, TokenNe, TokenLt, TokenLe, TokenGt, TokenGe:
+        return true
+    }
+    return false
+}

token.go

···
+package gott
+
+// TokenType represents the type of a lexical token
+type TokenType int
+
+const (
+    TokenError TokenType = iota // error occurred
+    TokenEOF                    // end of input
+
+    // Literals
+    TokenText   // raw text outside [% %]
+    TokenIdent  // identifier (variable name, block name)
+    TokenString // "string" or 'string'
+    TokenNumber // 123 or 45.67
+
+    // Delimiters
+    TokenTagOpen  // [%
+    TokenTagClose // %]
+    TokenLParen   // (
+    TokenRParen   // )
+    TokenDot      // .
+    TokenPipe     // |
+    TokenComma    // ,
+    TokenAssign   // =
+
+    // Operators
+    TokenOr    // ||
+    TokenAnd   // &&
+    TokenEq    // ==
+    TokenNe    // !=
+    TokenLt    // <
+    TokenLe    // <=
+    TokenGt    // >
+    TokenGe    // >=
+    TokenPlus  // +
+    TokenMinus // -
+    TokenMul   // *
+    TokenDiv   // /
+    TokenMod   // % (modulo, only inside tags)
+
+    // Keywords
+    TokenIF
+    TokenELSIF
+    TokenELSE
+    TokenUNLESS
+    TokenEND
+    TokenFOREACH
+    TokenIN
+    TokenBLOCK
+    TokenINCLUDE
+    TokenWRAPPER
+    TokenSET
+)
+
+// String returns a human-readable name for the token type
+func (t TokenType) String() string {
+    switch t {
+    case TokenError:
+        return "Error"
+    case TokenEOF:
+        return "EOF"
+    case TokenText:
+        return "Text"
+    case TokenIdent:
+        return "Ident"
+    case TokenString:
+        return "String"
+    case TokenNumber:
+        return "Number"
+    case TokenTagOpen:
+        return "[%"
+    case TokenTagClose:
+        return "%]"
+    case TokenLParen:
+        return "("
+    case TokenRParen:
+        return ")"
+    case TokenDot:
+        return "."
+    case TokenPipe:
+        return "|"
+    case TokenComma:
+        return ","
+    case TokenAssign:
+        return "="
+    case TokenOr:
+        return "||"
+    case TokenAnd:
+        return "&&"
+    case TokenEq:
+        return "=="
+    case TokenNe:
+        return "!="
+    case TokenLt:
+        return "<"
+    case TokenLe:
+        return "<="
+    case TokenGt:
+        return ">"
+    case TokenGe:
+        return ">="
+    case TokenPlus:
+        return "+"
+    case TokenMinus:
+        return "-"
+    case TokenMul:
+        return "*"
+    case TokenDiv:
+        return "/"
+    case TokenMod:
+        return "%"
+    case TokenIF:
+        return "IF"
+    case TokenELSIF:
+        return "ELSIF"
+    case TokenELSE:
+        return "ELSE"
+    case TokenUNLESS:
+        return "UNLESS"
+    case TokenEND:
+        return "END"
+    case TokenFOREACH:
+        return "FOREACH"
+    case TokenIN:
+        return "IN"
+    case TokenBLOCK:
+        return "BLOCK"
+    case TokenINCLUDE:
+        return "INCLUDE"
+    case TokenWRAPPER:
+        return "WRAPPER"
+    case TokenSET:
+        return "SET"
+    default:
+        return "Unknown"
+    }
+}
+
+// Position represents a location in the source template
+type Position struct {
+    Line   int // 1-based line number
+    Column int // 1-based column number
+    Offset int // byte offset from start of input
+}
+
+// Token represents a lexical token with its type, value, and position
+type Token struct {
+    Type  TokenType
+    Value string   // literal value for idents, strings, numbers, text, errors
+    Pos   Position // source position for error reporting
+}
+
+// keywords maps keyword strings to their token types
+var keywords = map[string]TokenType{
+    "IF":      TokenIF,
+    "ELSIF":   TokenELSIF,
+    "ELSE":    TokenELSE,
+    "UNLESS":  TokenUNLESS,
+    "END":     TokenEND,
+    "FOREACH": TokenFOREACH,
+    "IN":      TokenIN,
+    "BLOCK":   TokenBLOCK,
+    "INCLUDE": TokenINCLUDE,
+    "WRAPPER": TokenWRAPPER,
+    "SET":     TokenSET,
+}
+
+// LookupKeyword returns the token type for an identifier,
+// returning TokenIdent if it's not a keyword
+func LookupKeyword(ident string) TokenType {
+    if tok, ok := keywords[ident]; ok {
+        return tok
+    }
+    return TokenIdent
+}