{{ .Title }}
+{{ .Body | truncate 200 }}
+ +{{ .Name }}
+ {{ end }} + {{ template "footer" . }} + +` + goTplPath := filepath.Join(tmpDir, "gotpl.html") + require.NoError(t, os.WriteFile(goTplPath, []byte(goTplHTML), 0644)) + + res, err := analyzer.Analyze(context.Background(), goTplPath) + require.NoError(t, err) + + // Should have BOTH Go template symbols AND HTML symbols + assert.Greater(t, len(res.Symbols), 1, "expected both Go template and HTML symbols") + + // Verify Go template symbol exists with correct metadata + foundGoTpl := false + for _, s := range res.Symbols { + if md, ok := s.Metadata["template_type"]; ok && md == "go_template" { + foundGoTpl = true + // Should have includes relation to "footer" + foundRel := false + for _, rel := range s.Relations { + if rel.TargetName == "footer" { + foundRel = true + } + } + assert.True(t, foundRel, "expected relation to 'footer' template") + } + } + assert.True(t, foundGoTpl, "expected go_template symbol") + }) + + t.Run("Tmpl_file", func(t *testing.T) { + tmplContent := `{{ define "sidebar" }} + +{{ end }}` + tmplPath := filepath.Join(tmpDir, "sidebar.tmpl") + require.NoError(t, os.WriteFile(tmplPath, []byte(tmplContent), 0644)) + + res, err := analyzer.Analyze(context.Background(), tmplPath) + require.NoError(t, err) + + // Should produce Go template symbols + assert.Greater(t, len(res.Symbols), 0) + + foundDefine := false + for _, s := range res.Symbols { + if md, ok := s.Metadata["define_name"]; ok && md == "sidebar" { + foundDefine = true + } + } + assert.True(t, foundDefine, "expected define 'sidebar' symbol") + }) } diff --git a/pkg/parser/html/gotemplate/adapter.go b/pkg/parser/html/gotemplate/adapter.go new file mode 100644 index 0000000..e0c2852 --- /dev/null +++ b/pkg/parser/html/gotemplate/adapter.go @@ -0,0 +1,190 @@ +package gotemplate + +import ( + "fmt" + "path/filepath" + "strings" + + pkgParser "github.com/doITmagic/rag-code-mcp/pkg/parser" +) + +// ConvertToSymbols converts parsed GoTemplate results to parser.Symbol entries +// with structural relations: +// - RelDependency for {{ template "name" }} includes +// - RelInheritance for {{ block "name" }} (defines overridable default content) +func ConvertToSymbols(templates []GoTemplate) []pkgParser.Symbol { + var symbols []pkgParser.Symbol + + for _, tpl := range templates { + baseName := filepath.Base(tpl.FilePath) + nameNoExt := strings.TrimSuffix(baseName, filepath.Ext(baseName)) + + // If template has {{ define }} blocks, create a symbol per define. + if len(tpl.Defines) > 0 { + for _, def := range tpl.Defines { + sym := buildDefineSymbol(tpl, def) + symbols = append(symbols, sym) + } + } + + // Always create a file-level symbol for the whole template. + sym := buildFileSymbol(tpl, nameNoExt) + symbols = append(symbols, sym) + } + + return symbols +} + +// buildFileSymbol creates a file-level symbol representing the entire template. +func buildFileSymbol(tpl GoTemplate, nameNoExt string) pkgParser.Symbol { + // Build signature summary + var sigParts []string + sigParts = append(sigParts, "go_template") + if len(tpl.Defines) > 0 { + names := make([]string, len(tpl.Defines)) + for i, d := range tpl.Defines { + names[i] = d.Name + } + sigParts = append(sigParts, fmt.Sprintf("defines: %s", strings.Join(names, ", "))) + } + if len(tpl.TemplateIncludes) > 0 { + names := make([]string, len(tpl.TemplateIncludes)) + for i, t := range tpl.TemplateIncludes { + names[i] = t.Name + } + sigParts = append(sigParts, fmt.Sprintf("includes: %s", strings.Join(names, ", "))) + } + if len(tpl.Blocks) > 0 { + names := make([]string, len(tpl.Blocks)) + for i, b := range tpl.Blocks { + names[i] = b.Name + } + sigParts = append(sigParts, fmt.Sprintf("blocks: %s", strings.Join(names, ", "))) + } + + // Build docstring + var docParts []string + if len(tpl.Variables) > 0 { + docParts = append(docParts, fmt.Sprintf("Variables: %s", strings.Join(tpl.Variables, ", "))) + } + if len(tpl.CustomFuncs) > 0 { + docParts = append(docParts, fmt.Sprintf("Custom funcs: %s", strings.Join(tpl.CustomFuncs, ", "))) + } + if len(tpl.Ranges) > 0 { + vars := make([]string, len(tpl.Ranges)) + for i, r := range tpl.Ranges { + vars[i] = r.Variable + } + docParts = append(docParts, fmt.Sprintf("Iterates: %s", strings.Join(vars, ", "))) + } + + // Build relations: template includes → dependency + var relations []pkgParser.Relation + for _, inc := range tpl.TemplateIncludes { + relations = append(relations, pkgParser.Relation{ + TargetName: inc.Name, + Type: pkgParser.RelDependency, + }) + } + // Build relations: blocks → inheritance (overridable default content) + for _, blk := range tpl.Blocks { + relations = append(relations, pkgParser.Relation{ + TargetName: blk.Name, + Type: pkgParser.RelInheritance, + }) + } + + endLine := tpl.TotalLines + if endLine < 1 { + endLine = 1 + } + + return pkgParser.Symbol{ + Name: nameNoExt, + Type: pkgParser.Type, + FilePath: tpl.FilePath, + Language: "html", + StartLine: 1, + EndLine: endLine, + Signature: strings.Join(sigParts, " | "), + Docstring: strings.Join(docParts, " | "), + IsPublic: true, + Relations: relations, + Metadata: map[string]any{ + "template_type": "go_template", + "defines": extractDefineNames(tpl), + "includes": extractIncludeNames(tpl), + "blocks": extractBlockNames(tpl), + "variables": tpl.Variables, + "custom_funcs": tpl.CustomFuncs, + "ranges": extractRangeVars(tpl), + }, + } +} + +// buildDefineSymbol creates a symbol for a specific {{ define "name" }} block. +func buildDefineSymbol(tpl GoTemplate, def DefineDirective) pkgParser.Symbol { + endLine := def.EndLine + if endLine < def.Line { + endLine = def.Line + } + + // Relations: any {{ template "x" }} inside this define are dependencies + var relations []pkgParser.Relation + for _, inc := range tpl.TemplateIncludes { + if inc.Line >= def.Line && inc.Line <= endLine { + relations = append(relations, pkgParser.Relation{ + TargetName: inc.Name, + Type: pkgParser.RelDependency, + }) + } + } + + return pkgParser.Symbol{ + Name: def.Name, + Type: pkgParser.Type, + FilePath: tpl.FilePath, + Language: "html", + StartLine: def.Line, + EndLine: endLine, + Signature: fmt.Sprintf(`go_template | {{ define "%s" }}`, def.Name), + IsPublic: true, + Relations: relations, + Metadata: map[string]any{ + "template_type": "go_template_define", + "define_name": def.Name, + }, + } +} + +func extractDefineNames(tpl GoTemplate) []string { + names := make([]string, len(tpl.Defines)) + for i, d := range tpl.Defines { + names[i] = d.Name + } + return names +} + +func extractIncludeNames(tpl GoTemplate) []string { + names := make([]string, len(tpl.TemplateIncludes)) + for i, t := range tpl.TemplateIncludes { + names[i] = t.Name + } + return names +} + +func extractBlockNames(tpl GoTemplate) []string { + names := make([]string, len(tpl.Blocks)) + for i, b := range tpl.Blocks { + names[i] = b.Name + } + return names +} + +func extractRangeVars(tpl GoTemplate) []string { + vars := make([]string, len(tpl.Ranges)) + for i, r := range tpl.Ranges { + vars[i] = r.Variable + } + return vars +} diff --git a/pkg/parser/html/gotemplate/adapter_test.go b/pkg/parser/html/gotemplate/adapter_test.go new file mode 100644 index 0000000..f64c37f --- /dev/null +++ b/pkg/parser/html/gotemplate/adapter_test.go @@ -0,0 +1,122 @@ +package gotemplate + +import ( + "testing" + + pkgParser "github.com/doITmagic/rag-code-mcp/pkg/parser" +) + +func TestConvertToSymbols_Layout(t *testing.T) { + ba := &GoTemplateAnalyzer{} + templates := ba.Analyze([]string{testdataPath("layout.html")}) + symbols := ConvertToSymbols(templates) + + if len(symbols) == 0 { + t.Fatal("expected at least 1 symbol") + } + + // Should have 2 symbols: one for {{ define "base" }}, one file-level + if len(symbols) != 2 { + t.Fatalf("expected 2 symbols (1 define + 1 file), got %d", len(symbols)) + } + + // First symbol: the define "base" + defSym := symbols[0] + if defSym.Name != "base" { + t.Errorf("expected define symbol name 'base', got %q", defSym.Name) + } + if defSym.Metadata["template_type"] != "go_template_define" { + t.Errorf("expected template_type=go_template_define, got %v", defSym.Metadata["template_type"]) + } + // Should have relation to "nav" ({{ template "nav" }} is inside define "base") + foundNavRel := false + for _, rel := range defSym.Relations { + if rel.TargetName == "nav" && rel.Type == pkgParser.RelDependency { + foundNavRel = true + } + } + if !foundNavRel { + t.Errorf("expected relation to 'nav', got %v", defSym.Relations) + } + + // Second symbol: file-level + fileSym := symbols[1] + if fileSym.Metadata["template_type"] != "go_template" { + t.Errorf("expected template_type=go_template, got %v", fileSym.Metadata["template_type"]) + } + // Signature should contain "defines: base" + if fileSym.Signature == "" { + t.Error("expected non-empty signature") + } + + // File-level should have includes relation + foundIncRel := false + for _, rel := range fileSym.Relations { + if rel.TargetName == "nav" && rel.Type == pkgParser.RelDependency { + foundIncRel = true + } + } + if !foundIncRel { + t.Errorf("expected file-level relation to 'nav', got %v", fileSym.Relations) + } +} + +func TestConvertToSymbols_Partial(t *testing.T) { + ba := &GoTemplateAnalyzer{} + templates := ba.Analyze([]string{testdataPath("partial.gohtml")}) + symbols := ConvertToSymbols(templates) + + // No defines → only 1 file-level symbol + if len(symbols) != 1 { + t.Fatalf("expected 1 symbol (file-level only), got %d", len(symbols)) + } + + sym := symbols[0] + if sym.Name != "partial" { + t.Errorf("expected name 'partial', got %q", sym.Name) + } + if sym.Language != "html" { + t.Errorf("expected language 'html', got %q", sym.Language) + } + + // Check metadata + vars, ok := sym.Metadata["variables"].([]string) + if !ok || len(vars) == 0 { + t.Error("expected variables in metadata") + } + rangeVars, ok := sym.Metadata["ranges"].([]string) + if !ok || len(rangeVars) == 0 { + t.Error("expected ranges in metadata") + } +} + +func TestConvertToSymbols_Metadata(t *testing.T) { + ba := &GoTemplateAnalyzer{} + templates := ba.Analyze([]string{testdataPath("page.tmpl")}) + symbols := ConvertToSymbols(templates) + + // page.tmpl has 1 define ("content") + 1 file-level + if len(symbols) != 2 { + t.Fatalf("expected 2 symbols, got %d", len(symbols)) + } + + fileSym := symbols[1] // file-level is always last + includes, ok := fileSym.Metadata["includes"].([]string) + if !ok { + t.Fatal("expected includes in metadata") + } + found := false + for _, inc := range includes { + if inc == "base" { + found = true + } + } + if !found { + t.Errorf("expected include 'base' in metadata, got %v", includes) + } + + customFuncs, ok := fileSym.Metadata["custom_funcs"].([]string) + if !ok || len(customFuncs) == 0 { + t.Error("expected custom_funcs in metadata") + } +} diff --git a/pkg/parser/html/gotemplate/analyzer.go b/pkg/parser/html/gotemplate/analyzer.go new file mode 100644 index 0000000..e9afe68 --- /dev/null +++ b/pkg/parser/html/gotemplate/analyzer.go @@ -0,0 +1,222 @@ +package gotemplate + +import ( + "bufio" + "os" + "path/filepath" + "regexp" + "strings" + + "github.com/doITmagic/rag-code-mcp/internal/logger" +) + +// Regex patterns for Go template directives. +var ( + reDefine = regexp.MustCompile(`\{\{-?\s*define\s+"([^"]+)"\s*-?\}\}`) + reBlock = regexp.MustCompile(`\{\{-?\s*block\s+"([^"]+)"\s*(\.[\w.]*)?\s*-?\}\}`) + reTemplate = regexp.MustCompile(`\{\{-?\s*template\s+"([^"]+)"\s*(\.[\w.]*)?\s*-?\}\}`) + reRange = regexp.MustCompile(`\{\{-?\s*range\s+(\.[\w.]+)\s*-?\}\}`) + reIf = regexp.MustCompile(`\{\{-?\s*if\s+(.+?)\s*-?\}\}`) + reElseIf = regexp.MustCompile(`\{\{-?\s*else\s+if\s+(.+?)\s*-?\}\}`) + reElse = regexp.MustCompile(`\{\{-?\s*else\s*-?\}\}`) + reWith = regexp.MustCompile(`\{\{-?\s*with\s+(\.[\w.]+)\s*-?\}\}`) + reEnd = regexp.MustCompile(`\{\{-?\s*end\s*-?\}\}`) + reComment = regexp.MustCompile(`\{\{/\*.*?\*/\}\}`) + reVariable = regexp.MustCompile(`\{\{-?\s*(\.[\w.]+)\s*-?\}\}`) + // Custom funcs: {{ funcName ... }} where funcName is not a keyword. + reCustomFunc = regexp.MustCompile(`\{\{-?\s*([a-zA-Z]\w+)\s+`) + + // Go template keywords that are NOT custom functions. + keywords = map[string]bool{ + "if": true, "else": true, "end": true, "range": true, + "with": true, "template": true, "define": true, "block": true, + "nil": true, "not": true, "and": true, "or": true, + "print": true, "printf": true, "println": true, + "len": true, "index": true, "slice": true, "call": true, + "html": true, "js": true, "urlquery": true, + "eq": true, "ne": true, "lt": true, "le": true, "gt": true, "ge": true, + } +) + +// GoTemplateAnalyzer parses Go template files and extracts directives. +type GoTemplateAnalyzer struct{} + +// Analyze parses the given template files, extracting directives. +func (a *GoTemplateAnalyzer) Analyze(filePaths []string) []GoTemplate { + var templates []GoTemplate + for _, fp := range filePaths { + tpl, err := a.analyzeFile(fp) + if err != nil { + logger.Instance.Debug("[GOTEMPLATE] skip %s: %v", filepath.Base(fp), err) + continue + } + templates = append(templates, tpl) + } + return templates +} + +// analyzeFile parses a single Go template file. +func (a *GoTemplateAnalyzer) analyzeFile(filePath string) (GoTemplate, error) { + file, err := os.Open(filePath) + if err != nil { + return GoTemplate{}, err + } + defer file.Close() + + tpl := GoTemplate{ + FilePath: filePath, + } + + // Track open blocks for EndLine matching. + type openBlock struct { + kind string // "define", "block", "range", "if", "with" + idx int // index in the corresponding slice + } + var stack []openBlock + + varSet := make(map[string]bool) + funcSet := make(map[string]bool) + + lineNum := 0 + scanner := bufio.NewScanner(file) + // Allow lines up to 1MB. + scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024) + + for scanner.Scan() { + lineNum++ + line := scanner.Text() + + // Comments (can be multiline in theory, but we handle single-line here) + if matches := reComment.FindAllString(line, -1); len(matches) > 0 { + tpl.Comments = append(tpl.Comments, matches...) + } + + // {{ define "name" }} + if m := reDefine.FindStringSubmatch(line); m != nil { + tpl.Defines = append(tpl.Defines, DefineDirective{ + Name: m[1], + Line: lineNum, + }) + stack = append(stack, openBlock{kind: "define", idx: len(tpl.Defines) - 1}) + } + + // {{ block "name" pipeline }} + if m := reBlock.FindStringSubmatch(line); m != nil { + pipeline := strings.TrimSpace(m[2]) + tpl.Blocks = append(tpl.Blocks, BlockDirective{ + Name: m[1], + Pipeline: pipeline, + Line: lineNum, + }) + stack = append(stack, openBlock{kind: "block", idx: len(tpl.Blocks) - 1}) + } + + // {{ template "name" pipeline }} + if m := reTemplate.FindStringSubmatch(line); m != nil { + pipeline := strings.TrimSpace(m[2]) + tpl.TemplateIncludes = append(tpl.TemplateIncludes, TemplateInclude{ + Name: m[1], + Pipeline: pipeline, + Line: lineNum, + }) + } + + // {{ range .Variable }} + if m := reRange.FindStringSubmatch(line); m != nil { + tpl.Ranges = append(tpl.Ranges, RangeDirective{ + Variable: m[1], + Line: lineNum, + }) + stack = append(stack, openBlock{kind: "range", idx: len(tpl.Ranges) - 1}) + } + + // {{ if .Condition }} + if m := reIf.FindStringSubmatch(line); m != nil { + tpl.Conditionals = append(tpl.Conditionals, ConditionalDirective{ + Condition: strings.TrimSpace(m[1]), + Line: lineNum, + }) + stack = append(stack, openBlock{kind: "if", idx: len(tpl.Conditionals) - 1}) + } + + // {{ else if .Cond }} — must check BEFORE bare {{ else }} + // NOTE: else-if does NOT push a new stack entry because Go templates + // use a single {{ end }} for the entire if/else-if/else chain. + if m := reElseIf.FindStringSubmatch(line); m != nil { + // Mark HasElse on the current if + for i := len(stack) - 1; i >= 0; i-- { + if stack[i].kind == "if" { + tpl.Conditionals[stack[i].idx].HasElse = true + break + } + } + // Record the else-if branch as a conditional (for metadata) + // but do NOT push onto stack — no extra {{ end }} expected. + tpl.Conditionals = append(tpl.Conditionals, ConditionalDirective{ + Condition: strings.TrimSpace(m[1]), + Line: lineNum, + HasElse: true, // part of an else-if chain + }) + } else if reElse.MatchString(line) { + // {{ else }} — bare else without condition + for i := len(stack) - 1; i >= 0; i-- { + if stack[i].kind == "if" { + tpl.Conditionals[stack[i].idx].HasElse = true + break + } + } + } + + // {{ with .Pipeline }} + if m := reWith.FindStringSubmatch(line); m != nil { + tpl.WithBlocks = append(tpl.WithBlocks, WithDirective{ + Pipeline: m[1], + Line: lineNum, + }) + stack = append(stack, openBlock{kind: "with", idx: len(tpl.WithBlocks) - 1}) + } + + // {{ end }} + if reEnd.MatchString(line) && len(stack) > 0 { + top := stack[len(stack)-1] + stack = stack[:len(stack)-1] + switch top.kind { + case "define": + tpl.Defines[top.idx].EndLine = lineNum + case "block": + tpl.Blocks[top.idx].EndLine = lineNum + case "range": + tpl.Ranges[top.idx].EndLine = lineNum + case "if": + tpl.Conditionals[top.idx].EndLine = lineNum + case "with": + tpl.WithBlocks[top.idx].EndLine = lineNum + } + } + + // Variables: {{ .Something }} — but not inside other directives we already captured + for _, m := range reVariable.FindAllStringSubmatch(line, -1) { + v := m[1] + if !varSet[v] { + varSet[v] = true + tpl.Variables = append(tpl.Variables, v) + } + } + + // Custom functions: {{ funcName arg }} where funcName is not a keyword + for _, m := range reCustomFunc.FindAllStringSubmatch(line, -1) { + funcName := m[1] + if !keywords[funcName] && !funcSet[funcName] { + funcSet[funcName] = true + tpl.CustomFuncs = append(tpl.CustomFuncs, funcName) + } + } + } + + if err := scanner.Err(); err != nil { + return GoTemplate{}, err + } + + tpl.TotalLines = lineNum + return tpl, nil +} diff --git a/pkg/parser/html/gotemplate/analyzer_test.go b/pkg/parser/html/gotemplate/analyzer_test.go new file mode 100644 index 0000000..b52eb4d --- /dev/null +++ b/pkg/parser/html/gotemplate/analyzer_test.go @@ -0,0 +1,256 @@ +package gotemplate + +import ( + "path/filepath" + "testing" +) + +func testdataPath(name string) string { + return filepath.Join("testdata", name) +} + +func TestAnalyze_Layout(t *testing.T) { + ba := &GoTemplateAnalyzer{} + templates := ba.Analyze([]string{testdataPath("layout.html")}) + + if len(templates) != 1 { + t.Fatalf("expected 1 template, got %d", len(templates)) + } + tpl := templates[0] + + // Defines + if len(tpl.Defines) != 1 { + t.Errorf("expected 1 define, got %d", len(tpl.Defines)) + } else if tpl.Defines[0].Name != "base" { + t.Errorf("expected define name 'base', got %q", tpl.Defines[0].Name) + } + + // Template includes + if len(tpl.TemplateIncludes) != 1 { + t.Errorf("expected 1 template include, got %d: %v", len(tpl.TemplateIncludes), tpl.TemplateIncludes) + } else if tpl.TemplateIncludes[0].Name != "nav" { + t.Errorf("expected template include 'nav', got %q", tpl.TemplateIncludes[0].Name) + } + + // Blocks + if len(tpl.Blocks) != 1 { + t.Errorf("expected 1 block, got %d: %v", len(tpl.Blocks), tpl.Blocks) + } else if tpl.Blocks[0].Name != "content" { + t.Errorf("expected block 'content', got %q", tpl.Blocks[0].Name) + } + + // Ranges + if len(tpl.Ranges) != 1 { + t.Errorf("expected 1 range, got %d: %v", len(tpl.Ranges), tpl.Ranges) + } else if tpl.Ranges[0].Variable != ".Items" { + t.Errorf("expected range variable '.Items', got %q", tpl.Ranges[0].Variable) + } + + // Conditionals + if len(tpl.Conditionals) != 1 { + t.Errorf("expected 1 conditional, got %d: %v", len(tpl.Conditionals), tpl.Conditionals) + } else { + cond := tpl.Conditionals[0] + if cond.Condition != ".IsAdmin" { + t.Errorf("expected condition '.IsAdmin', got %q", cond.Condition) + } + if !cond.HasElse { + t.Error("expected HasElse=true") + } + } + + // With + if len(tpl.WithBlocks) != 1 { + t.Errorf("expected 1 with block, got %d: %v", len(tpl.WithBlocks), tpl.WithBlocks) + } else if tpl.WithBlocks[0].Pipeline != ".Footer" { + t.Errorf("expected with pipeline '.Footer', got %q", tpl.WithBlocks[0].Pipeline) + } + + // Comments + if len(tpl.Comments) != 1 { + t.Errorf("expected 1 comment, got %d: %v", len(tpl.Comments), tpl.Comments) + } + + // Custom funcs + if len(tpl.CustomFuncs) == 0 { + t.Error("expected at least 1 custom func (formatDate)") + } else { + found := false + for _, f := range tpl.CustomFuncs { + if f == "formatDate" { + found = true + break + } + } + if !found { + t.Errorf("expected custom func 'formatDate', got %v", tpl.CustomFuncs) + } + } + + // TotalLines + if tpl.TotalLines == 0 { + t.Error("expected TotalLines > 0") + } +} + +func TestAnalyze_Page(t *testing.T) { + ba := &GoTemplateAnalyzer{} + templates := ba.Analyze([]string{testdataPath("page.tmpl")}) + + if len(templates) != 1 { + t.Fatalf("expected 1 template, got %d", len(templates)) + } + tpl := templates[0] + + // Template includes ({{ template "base" . }}) + if len(tpl.TemplateIncludes) != 1 { + t.Errorf("expected 1 template include, got %d", len(tpl.TemplateIncludes)) + } else if tpl.TemplateIncludes[0].Name != "base" { + t.Errorf("expected include 'base', got %q", tpl.TemplateIncludes[0].Name) + } + + // Defines ({{ define "content" }}) + if len(tpl.Defines) != 1 { + t.Errorf("expected 1 define, got %d", len(tpl.Defines)) + } else if tpl.Defines[0].Name != "content" { + t.Errorf("expected define 'content', got %q", tpl.Defines[0].Name) + } + + // Ranges + if len(tpl.Ranges) != 1 { + t.Errorf("expected 1 range, got %d", len(tpl.Ranges)) + } else if tpl.Ranges[0].Variable != ".Posts" { + t.Errorf("expected range '.Posts', got %q", tpl.Ranges[0].Variable) + } + + // Custom funcs + found := false + for _, f := range tpl.CustomFuncs { + if f == "formatDate" { + found = true + break + } + } + if !found { + t.Errorf("expected custom func 'formatDate', got %v", tpl.CustomFuncs) + } +} + +func TestAnalyze_Partial(t *testing.T) { + ba := &GoTemplateAnalyzer{} + templates := ba.Analyze([]string{testdataPath("partial.gohtml")}) + + if len(templates) != 1 { + t.Fatalf("expected 1 template, got %d", len(templates)) + } + tpl := templates[0] + + // Conditionals + if len(tpl.Conditionals) != 1 { + t.Errorf("expected 1 conditional, got %d", len(tpl.Conditionals)) + } + + // Ranges + if len(tpl.Ranges) != 1 { + t.Errorf("expected 1 range, got %d", len(tpl.Ranges)) + } else if tpl.Ranges[0].Variable != ".Widgets" { + t.Errorf("expected range '.Widgets', got %q", tpl.Ranges[0].Variable) + } +} + +func TestAnalyze_MultipleFiles(t *testing.T) { + ba := &GoTemplateAnalyzer{} + templates := ba.Analyze([]string{ + testdataPath("layout.html"), + testdataPath("page.tmpl"), + testdataPath("partial.gohtml"), + }) + + if len(templates) != 3 { + t.Fatalf("expected 3 templates, got %d", len(templates)) + } +} + +func TestAnalyze_NonexistentFile(t *testing.T) { + ba := &GoTemplateAnalyzer{} + templates := ba.Analyze([]string{"testdata/nonexistent.html"}) + + if len(templates) != 0 { + t.Errorf("expected 0 templates for nonexistent file, got %d", len(templates)) + } +} + +func TestAnalyze_ElseIf(t *testing.T) { + ba := &GoTemplateAnalyzer{} + templates := ba.Analyze([]string{testdataPath("elseif.tmpl")}) + + if len(templates) != 1 { + t.Fatalf("expected 1 template, got %d", len(templates)) + } + tpl := templates[0] + + // Should have 3 conditionals: if .IsAdmin, else if .IsModerator, else if .IsEditor + if len(tpl.Conditionals) < 3 { + t.Errorf("expected at least 3 conditionals (if + 2 else-if), got %d: %v", + len(tpl.Conditionals), tpl.Conditionals) + } + + // First conditional (.IsAdmin) should have HasElse=true + if len(tpl.Conditionals) > 0 { + if tpl.Conditionals[0].Condition != ".IsAdmin" { + t.Errorf("expected first condition '.IsAdmin', got %q", tpl.Conditionals[0].Condition) + } + if !tpl.Conditionals[0].HasElse { + t.Error("expected first conditional HasElse=true (has else-if branch)") + } + } + + // Second conditional (.IsModerator) from else-if + if len(tpl.Conditionals) > 1 { + if tpl.Conditionals[1].Condition != ".IsModerator" { + t.Errorf("expected second condition '.IsModerator', got %q", tpl.Conditionals[1].Condition) + } + } + + // Third conditional (.IsEditor) from else-if + if len(tpl.Conditionals) > 2 { + if tpl.Conditionals[2].Condition != ".IsEditor" { + t.Errorf("expected third condition '.IsEditor', got %q", tpl.Conditionals[2].Condition) + } + } + + // Defines + if len(tpl.Defines) != 1 { + t.Errorf("expected 1 define, got %d", len(tpl.Defines)) + } else if tpl.Defines[0].Name != "dashboard" { + t.Errorf("expected define 'dashboard', got %q", tpl.Defines[0].Name) + } +} + +func TestAnalyze_BlockRelations(t *testing.T) { + ba := &GoTemplateAnalyzer{} + templates := ba.Analyze([]string{testdataPath("layout.html")}) + + if len(templates) != 1 { + t.Fatalf("expected 1 template, got %d", len(templates)) + } + + // Convert and check for RelInheritance on blocks + symbols := ConvertToSymbols(templates) + if len(symbols) == 0 { + t.Fatal("expected at least 1 symbol") + } + + // File-level symbol should have RelInheritance for block "content" + var hasInheritance bool + for _, sym := range symbols { + for _, rel := range sym.Relations { + if rel.Type == "inheritance" && rel.TargetName == "content" { + hasInheritance = true + } + } + } + if !hasInheritance { + t.Error("expected RelInheritance for block 'content' in symbols") + } +} diff --git a/pkg/parser/html/gotemplate/testdata/elseif.tmpl b/pkg/parser/html/gotemplate/testdata/elseif.tmpl new file mode 100644 index 0000000..ba41b45 --- /dev/null +++ b/pkg/parser/html/gotemplate/testdata/elseif.tmpl @@ -0,0 +1,23 @@ +{{ define "dashboard" }} +{{ .Bio }}
+{{ end }} + +{{/* Dashboard template with else-if chains */}} +Default content
+ {{ end }} + + {{ range .Items }} +{{ .Body | truncate 200 }}
+ +