From f04532229b76a836c175814e209fca315b884de7 Mon Sep 17 00:00:00 2001
From: Spencer Brower <6729162+sbrow@users.noreply.github.com>
Date: Tue, 21 Jul 2026 12:23:23 -0400
Subject: [PATCH] feat: Added Rust-style error messages for template errors.
---
AGENTS.md | 114 +++++--
TODOS.md | 3 +
mustache/diagnostic.odin | 332 ++++++++++++++++++++
mustache/diagnostic_test.odin | 576 ++++++++++++++++++++++++++++++++++
mustache/mustache.odin | 280 ++++++++++++++---
mustache/mustache_test.odin | 7 +-
mustache/pipes.odin | 50 ++-
mustache/pipes_test.odin | 25 +-
mustache/spec_test.odin | 9 +-
mustache/suggest.odin | 206 ++++++++++++
mustache/suggest_test.odin | 194 ++++++++++++
render.odin | 79 ++++-
vfs.odin | 32 ++
13 files changed, 1786 insertions(+), 121 deletions(-)
create mode 100644 mustache/diagnostic.odin
create mode 100644 mustache/diagnostic_test.odin
create mode 100644 mustache/suggest.odin
create mode 100644 mustache/suggest_test.odin
diff --git a/AGENTS.md b/AGENTS.md
index 8b245c7..6e17f71 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -5,7 +5,7 @@ Thor is a static site generator written in [Odin](https://odin-lang.org), replac
## Architecture
```
-thor.json ← site config (title, base_url, params, modules)
+thor.json ← site config (title, base_url, params, modules, og)
content/ ← markdown and HTML content files
layouts/ ← Mustache templates + partials (user overrides)
assets/ ← CSS (Tufte-based), JS, fonts, images
@@ -19,7 +19,7 @@ public/ ← build output (generated)
thor/
├── treesitter/ # FFI types + grammar management (standalone package)
├── markdown/ # Content transformation pipeline (imports ../treesitter)
-├── mustache/ # Template engine with lambdas + pipe filters
+├── mustache/ # Template engine with lambdas + pipe filters + diagnostics
├── content.odin # Page struct, scan_content, load_page
├── render.odin # Template rendering, data structs, RSS, sitemap
├── site.odin # Config (Flags, Config_File, Site), init_site
@@ -27,8 +27,9 @@ thor/
├── feed.odin # RSS + sitemap generation
├── vfs.odin # Union file system (defaults → modules → site)
├── assets.odin # VFS-based asset copying
-├── opengraph.odin # Open_Graph struct + og_init/og_for_page
-├── frontmatter.odin # JSON frontmatter parser
+├── html.odin # HTML helpers: strip_html_tags, unescape_html, generate_summary
+├── opengraph.odin # Open_Graph struct + og_for_site/og_for_page
+├── frontmatter.odin # JSON frontmatter parser (supports nested og + lastmod)
├── defaults.odin # DEFAULTS_PATH constant (#directory)
├── main.odin # Entry point
└── defaults/layouts/ # Bundled default templates
@@ -39,15 +40,16 @@ thor/
| File | Responsibility |
|---|---|
| `main.odin` | Entry point. Sets `context.logger`, calls `init_site`, `build_vfs`, `site_load_content`, `render_site`. Optional Spall profiling via `SPALL` config flag. |
-| `site.odin` | `Flags` (CLI), `Config_File` (thor.json), `Site` (runtime state + arena + VFS + pages + modules). `Feature` enum. 5-step `init_site`. Imports `md "markdown"` for `Extension` enum. |
-| `content.odin` | `Page` struct, `scan_content` (section-aware walk that handles leaf bundles), `load_page`, `infer_layout`. Calls `md.process()` for the markdown pipeline. |
+| `site.odin` | `Flags` (CLI), `Config_File` (thor.json, includes `og: Open_Graph`), `Site` (runtime state + arena + VFS + pages + modules + `og`). `Feature` enum. 5-step `init_site`. Imports `md "markdown"` for `Extension` enum. |
+| `content.odin` | `Page` struct (includes `lastmod`, `og`), `scan_content` (section-aware walk that handles leaf bundles), `load_page`, `infer_layout`. Calls `md.process()` for the markdown pipeline. |
| `render.odin` | Template rendering: `render_site`, `render_page_html`, `render_home_html`, `render_section`. Data structs (`Base_Data`, `Page_Data`, `Home_Data`, `Section_Data`). VFS-based template loading with fallback chain (`get_template`). |
| `minify.odin` | HTML/CSS minification via tree-sitter. Imports `ts "treesitter"`. |
| `feed.odin` | RSS feed + sitemap XML. Uses `page.url` for canonical URLs. |
-| `vfs.odin` | Union file system: `VFS`, `build_vfs`, `mount_dir`, `mount_subdir`, `mount_recursive`, `vfs_get`. Layers defaults → modules → site. |
+| `vfs.odin` | Union file system: `VFS`, `build_vfs`, `mount_dir`, `mount_subdir`, `mount_recursive`, `vfs_get`, `vfs_get_entry`, `vfs_entry_data`. Layers defaults → modules → site. |
| `assets.odin` | `copy_assets_dir` — iterates VFS entries with `assets/` prefix, minifies CSS, copies verbatim or via `os.copy_file`. |
-| `opengraph.odin` | `Open_Graph` struct (fields ordered per OGP spec). `og_init(site)` for site defaults, `og_for_page(site, page, base)` for page-specific OG data. |
-| `frontmatter.odin` | JSON frontmatter parser (`{ }` delimited). Supports `layout` field for template override. |
+| `html.odin` | `strip_html_tags` (moved from render.odin), `unescape_html`, `generate_summary` (Hugo-style body summary for OG descriptions). |
+| `opengraph.odin` | `Open_Graph` struct (fields ordered per OGP spec, `is_article: Maybe(bool)`). `og_for_site(site)` for site defaults (from config + derived), `og_for_page(site_og, page)` for page-specific (overlay page.og + derive from page data). |
+| `frontmatter.odin` | JSON frontmatter parser (`{ }` delimited). Supports `layout`, `lastmod`, and nested `og` object (via `json_get_open_graph`). |
| `defaults.odin` | `DEFAULTS_PATH` constant, resolved at compile time via `#directory` so bundled templates ship in the binary. |
### Subpackages
@@ -90,10 +92,12 @@ Page :: struct {
title: string,
description: string,
date: string,
+ lastmod: string,
menu: string,
body_html: string,
draft: bool,
is_starred: bool,
+ og: Open_Graph, // per-page OG overrides from frontmatter
_is_index: bool `private`,
}
```
@@ -112,8 +116,8 @@ No `Page_Type` enum — page type is inferred from section + `_is_index`. Layout
Config is split into three structs with a clear 5-step initialization flow:
- **`Flags`** — CLI args only. Parsed by `core:flags`. Includes path overrides (`--content`, `--assets`, `--output`, `--layouts`), build-mode toggles (`-drafts`, `-watch`, `-minify`), and `-ext`/`-no-ext` for markdown extension overrides.
-- **`Config_File`** — parsed from `thor.json` via `json.unmarshal_string`. Holds title, paths, `markdown_extensions` (JSON), `params` (JSON), `modules` (JSON array of relative paths).
-- **`Site`** — runtime state: arena, pages, modules, VFS, `features: bit_set[Feature]`, `markdown_extensions: bit_set[md.Extension]`.
+- **`Config_File`** — parsed from `thor.json` via `json.unmarshal_string`. Holds title, paths, `markdown_extensions` (JSON), `params` (JSON), `modules` (JSON array of relative paths), `og` (`Open_Graph` struct for site-level OG defaults).
+- **`Site`** — runtime state: arena, pages, modules, VFS, `features: bit_set[Feature]`, `markdown_extensions: bit_set[md.Extension]`, `og: Open_Graph` (resolved site-level OG).
**`Feature` enum** — `Drafts`, `Minify`, `Watch`. Checked with `.Minify in site.features`.
@@ -130,15 +134,11 @@ Config precedence: `CLI flags > thor.json values > hardcoded defaults`.
"title": "...",
"base_url": "...",
"modules": ["../path/to/module"],
- "markdown_extensions": {
- "emoji": true,
- "sidenotes": true,
- "alerts": true,
- "highlight": true,
- "sections": true
+ "og": {
+ "image": "https://example.com/og.png"
},
+ "markdown_extensions": { "emoji": true, "highlight": false },
"params": {
- "author": "...",
"social": [
{ "name": "github", "url": "...", "icon": "icons/github" }
]
@@ -155,13 +155,33 @@ VFS :: struct { files: map[string]VFS_Entry }
VFS_Entry :: struct { fs_path: string, data: []byte }
```
-`build_vfs` mounts in reverse precedence (defaults first, site last overwrites). `DEFAULTS_PATH` resolved at compile time via `#directory`, so bundled templates ship inside the binary. Modules configured via `"modules": ["../path"]` in `thor.json` — each module contributes `layouts/` and `assets/` subdirectories. `vfs_get` lazily reads file contents on first access.
+`build_vfs` mounts in reverse precedence (defaults first, site last overwrites). `DEFAULTS_PATH` resolved at compile time via `#directory`, so bundled templates ship inside the binary. Modules configured via `"modules": ["../path"]` in `thor.json` — each module contributes `layouts/` and `assets/` subdirectories.
+
+Three access patterns:
+- `vfs_get(vfs, path) -> ([]byte, bool)` — data only (lazy-loaded from disk)
+- `vfs_get_entry(vfs, path) -> (VFS_Entry, []byte, bool)` — entry + data (for callers that need `fs_path` for diagnostics)
+- `vfs_entry_data(entry) -> ([]byte, bool)` — data from an entry already in hand (avoids redundant map lookup when iterating `vfs.files`)
Content is **not yet in the VFS** — `scan_content` still uses direct filesystem reads. (See `TODOS.md`.)
## Open Graph
-`Open_Graph` struct in `opengraph.odin` with fields ordered per [ogp.me](https://ogp.me/) spec. Site defaults set via `og_init(site)` (site_name, description, default image, locale). Page-specific fields via `og_for_page(site, page, base)` (copies base, overrides url/title/type/is_article/section/published_time). Templates access via `{{og.url}}`, `{{og.title}}`, `{{#og.is_article}}`, etc.
+`Open_Graph` struct in `opengraph.odin` with fields ordered per [ogp.me](https://ogp.me/) spec. `is_article` is `Maybe(bool)` — nil means "unset" (distinguished from explicitly `false`).
+
+**Site-level** (`og_for_site`): starts from `Config_File.og` (user-supplied defaults from `thor.json`), then fills empty fields derivable from `Site`:
+- `site_name ← site.title`
+- `locale ← "en_US"` (default if unset)
+
+**Page-level** (`og_for_page`): copies site OG, derives page-specific fields, then overlays `Page.og` (from frontmatter):
+- `url ← page.url`
+- `title ← page.title` (falls back to `site_name` if empty)
+- `type ← "article" if !page._is_index else "website"`
+- `is_article ← !page._is_index`
+- `section ← page.section`
+- `published_time / modified_time ← page.date / page.lastmod`
+- `description ← page.description`, else body summary (via `generate_summary`)
+
+Paths through maps (e.g. `params.*`) are silently allowed — not validated. Templates access via `{{og.url}}`, `{{og.title}}`, `{{#og.is_article}}`, etc.
## Markdown pipeline
@@ -237,7 +257,7 @@ Section tags and interpolation tags may transform the resolved value before rend
```
-Currently implemented: `group_by ` (list → list-of-groups) and `format` (ISO date string → display string). Filter results live in `context.temp_allocator` (render-scoped). See `mustache/EXTENSIONS.md` for syntax details, caps (`MAX_PIPES`, `MAX_PIPE_ARGS`), and the `Group` struct shape.
+Currently implemented: `group_by ` (list → list-of-groups) and `format` (ISO date string → display string like "15 Mar 2026"). Filter results live in `context.temp_allocator` (render-scoped). See `mustache/EXTENSIONS.md` for syntax details, caps (`MAX_PIPES`, `MAX_PIPE_ARGS`), and the `Group` struct shape.
### Comments
@@ -310,40 +330,66 @@ nix build # runs thor, outputs to ./result/
```bash
cd thor
odin test . # main package tests (site, frontmatter)
-odin test . -all-packages # includes mustache specs, lambdas, pipes, markdown tests
+odin test . -all-packages # includes mustache specs, lambdas, pipes, diagnostics, markdown tests
```
## Mustache engine
-Spec-compliant implementation at `mustache/`. See `mustache/SPEC.md` for the implementation specification and `mustache/EXTENSIONS.md` for non-standard extensions (pipes).
+Spec-compliant implementation at `mustache/`. See `mustache/SPEC.md` for the implementation specification, `mustache/EXTENSIONS.md` for non-standard extensions (pipes), and `mustache/diagnostic.odin` for the rust-style error formatter.
### Files
| File | Responsibility |
|---|---|
-| `mustache.odin` | Public API (`parse`, `render`, `Template`), parser (`parse_section` with allocator threading), renderer (`render_nodes`), template inheritance (`merge_block_overrides`), `delete_template`/`delete_partials` |
+| `mustache.odin` | Public API (`parse`, `render`, `Template`), parser (`parse_section`), renderer (`render_nodes`, takes `Template` by value), template inheritance (`merge_block_overrides`), `delete_template`/`delete_partials`. Pipe support in Variable/Unescaped/Section/Inverted tags. |
| `tokenizer.odin` | Tokenizer (template string → `[]Token`), standalone whitespace detection |
-| `data.odin` | Reflection-based data model: `base_value` (peels union/any/nested-any layers), `lookup_in` (structs + maps, handles `Type_Info_Any` value kind in maps), `resolve_name`, `is_truthy`, `any_to_string`, `list_info`, `extract_list_element` (unwraps `[dynamic]any` element types so downstream lookups see the real value), `call_interp_lambda`/`call_section_lambda` |
-| `pipes.odin` | Pipes extension: `Pipe_Filter` AST, `parse_pipeline`, `apply_pipeline`, `apply_filter` (switch dispatch), `apply_group_by`. Stored on `Node.filters`; render-scoped results in temp allocator. |
-| `spec_test.odin` | JSON spec test runner — loads `spec/specs/*.json`, runs each test case |
+| `data.odin` | Reflection-based data model: `base_value` (peels union/any/nested-any layers), `lookup_in` (structs + maps, handles `Type_Info_Any` value kind in maps), `resolve_name`, `is_truthy`, `any_to_string`, `list_info`, `extract_list_element`, `call_interp_lambda`/`call_section_lambda` |
+| `pipes.odin` | Pipes extension: `Pipe_Filter` AST, `parse_pipeline` (takes `pos`), `apply_pipeline`, `apply_filter` (switch dispatch: `group_by` + `format`), `apply_group_by`, `apply_format`. Stored on `Node.filters`; render-scoped results in temp allocator. |
+| `diagnostic.odin` | Rust-style error formatter: `format_error` (multi-line context, ANSI colors via `core:terminal/ansi`, `colorize` param), `format_render_error` (dispatch on `Render_Error`), `line_col`, `line_text`, `context_extent`, `count_lines`, `digit_count`, `should_colorize`. |
+| `suggest.odin` | Strict-warning helpers: `validate_key_path` (walks dotted path, crosses maps silently), `suggest_correction` (Levenshtein via `core:strings/levenshtein_distance`), `collect_struct_keys` (via reflection, recurses into `using`), `struct_has_field` (distinguishes missing field from nil value — needed for `Maybe(bool)`), `collect_partial_names`, `collect_block_names`. |
+| `spec_test.odin` | JSON spec test runner — loads `spec/specs/*.json`, runs each test case. Uses `log.nil_logger()` to suppress expected warnings. |
| `lambda_test.odin` | Spec lambda tests |
-| `pipes_test.odin` | Pipe filter tests |
+| `pipes_test.odin` | Pipe filter tests (`group_by` + `format`) |
+| `diagnostic_test.odin` | Golden-output tests for `format_error` (multi-line context, edge cases, alignment, caret position, hint) + parser error message brace-escaping |
+| `suggest_test.odin` | Tests for `validate_key_path`, `suggest_correction`, `struct_has_field` with `Maybe(bool)` and `using`-promoted fields |
### Architecture
```
-parse(source) → tokenize → trim_standalone_whitespace → parse_section → Template
+parse(source, path) → tokenize → trim_standalone_whitespace → parse_section → Template
render(tmpl, data, partials) → render_nodes (walks flat node array against context stack) → string
```
- **Two-phase API**: `parse()` produces a reusable `Template`, `render()` walks it against data. Templates parsed once, rendered many times.
-- **Flat `[dynamic]Node` array** with `first_child`/`child_count` indices — pre-order layout.
+- **Flat `[dynamic]Node` array** with `first_child`/`child_count` indices — pre-order layout. Each `Node` carries `pos: int` (byte offset into source) for diagnostics.
+- **`Template`** carries `source` and `path` — used by diagnostics to show file location and source context.
- **Context stack**: `^[dynamic]any` with `append`/`pop` for section push/pop.
+- **`render_nodes` takes `Template` by value** (not `^Template`) — Odin's calling convention promotes to pointer when efficient. Eliminates "local copy" patterns at call sites.
+- **`Block_Override.source: Template`** — carries the template that defined the override, so warnings inside block overrides point at the correct file.
- **`base_value`** peels Named/Distinct/Union layers (including `json.Value`). Also unwraps nested `any`-of-`any` (which occurs when `map[string]any` values are read via runtime map internals).
- **`lookup_in`** resolves keys on structs (via `reflect.struct_field_value_by_name` with `allow_using = true`) and maps. Detects `Type_Info_Any` value kind in maps and reads the inner any directly to avoid double-wrap.
- **Template inheritance**: `{{*key}}` resolves partial name from data context at render time.
+### Diagnostics
+
+Rust-style error messages with multi-line source context, caret underlines, and Levenshtein suggestions. ANSI colors via `core:terminal/ansi`, gated on `should_colorize()` (TTY detection on stderr).
+
+**Error types**: `Syntax_Error{msg, pos}` and `Data_Error{msg, pos}` — both carry byte offset into template source. (`Partial_Error` was removed — dead code.)
+
+**Strict-by-default warnings** — `render_nodes` emits `log.warnf` diagnostics for:
+- Unknown keys in `{{k}}`, `{{{k}}}`, `{{#k}}`, `{{^k}}` (via `validate_key_path` + `suggest_correction`)
+- Missing partials (`{{> name}}` not in partials map)
+- Missing parent templates (`{{` is implemented (returns `[dynamic]Group` where `Group{key, items}`). See `mustache/EXTENSIONS.md`.
+`{{key | op args…}}` for interpolation, `{{#key | op args…}}…{{/key}}` for sections. Stored as `[dynamic; MAX_PIPES]Pipe_Filter` on each `Node`. Applied in the renderer via `apply_pipeline` before truthiness/interpolation. Implemented filters:
+
+- `group_by ` — list → `[dynamic]Group` where `Group{key, items}`
+- `format` — ISO 8601 date string → display string (e.g., "15 Mar 2026")
+
+See `mustache/EXTENSIONS.md`.
### Not implemented
- Set delimiters (`{{= =}}`, `delimiters.json`)
+- Partial invocation stack in diagnostics (warnings inside partials point at the partial file but don't show the `{{> name}}` invocation site — see TODOS.md)
## Known limitations
diff --git a/TODOS.md b/TODOS.md
index 1df169d..05a9f87 100644
--- a/TODOS.md
+++ b/TODOS.md
@@ -27,6 +27,7 @@
- Allows users to verify their output didn't change after upgrading to a new version
- [ ] Content-hash fingerprinting for CSS and JS cache busting
- [ ] Avoid `json.Value` / `json.Object` where possible.
+- [ ] make `parse` an overload of `parse_text/parse_inline` and `parse_file`, or something.
- [ ] Add page params
- [ ] We must remove all mention of `posts` from the odin code.
At present, "posts" are a user-level construct defined as pages in a
@@ -111,6 +112,8 @@ these tasks.
- [ ] Review markdown.odin
- [x] Review sectionate.odin
- [x] Review sectionate_test.odin
+ - [ ] Review suggest.odin
+ - [ ] Review suggest_test.odin
- [x] Review opengraph.odin
- [ ] Review render.odin
- [x] Review site.odin
diff --git a/mustache/diagnostic.odin b/mustache/diagnostic.odin
new file mode 100644
index 0000000..fba81d0
--- /dev/null
+++ b/mustache/diagnostic.odin
@@ -0,0 +1,332 @@
+package mustache
+
+import "core:fmt"
+import "core:os"
+import "core:strings"
+import "core:terminal/ansi"
+import "core:unicode/utf8"
+
+// line_col returns the 1-indexed line and column for a byte offset in source.
+// Newlines ('\n') separate lines; '\r' is treated as part of '\r\n'. Column is
+// counted in bytes from the start of the line.
+line_col :: proc(source: string, pos_in: int) -> (line: int, col: int) {
+ pos := pos_in
+ if pos < 0 {
+ return 1, 1
+ }
+ if pos > len(source) {
+ pos = len(source)
+ }
+ line = 1
+ col = 1
+ for i := 0; i < pos; i += 1 {
+ if source[i] == '\n' {
+ line += 1
+ col = 1
+ } else {
+ col += 1
+ }
+ }
+ return
+}
+
+// line_text returns the Nth (1-indexed) line of source, without the trailing
+// newline. Returns "" if line is out of range.
+line_text :: proc(source: string, line: int) -> string {
+ if line < 1 {
+ return ""
+ }
+ current := 1
+ start := 0
+ for i := 0; i < len(source); i += 1 {
+ if current == line {
+ end := i
+ for end < len(source) && source[end] != '\n' {
+ end += 1
+ }
+ return source[start:end]
+ }
+ if source[i] == '\n' {
+ current += 1
+ start = i + 1
+ }
+ }
+ if current == line {
+ return source[start:]
+ }
+ return ""
+}
+
+// context_extent returns the byte offset of the start of the line containing
+// pos, plus the byte offsets of the start and end of the mustache tag at pos.
+// Used to underline the offending tag. If pos is not inside a tag, the
+// returned [token_start, token_end) is a single rune at pos.
+context_extent :: proc(
+ source: string,
+ pos_in: int,
+) -> (
+ line_start: int,
+ token_start: int,
+ token_end: int,
+) {
+ pos := pos_in
+ if pos < 0 {
+ return 0, 0, 0
+ }
+ if pos >= len(source) {
+ pos = len(source) - 1
+ }
+ line_start = pos
+ for line_start > 0 && source[line_start - 1] != '\n' {
+ line_start -= 1
+ }
+
+ // Scan forward from line_start for `{{ ... }}` tags. If pos falls inside
+ // any tag's byte range, return that tag's extent.
+ i := line_start
+ for i + 1 < len(source) {
+ if source[i] == '{' && source[i + 1] == '{' {
+ tag_start := i
+ // Find closing }}
+ j := i + 2
+ depth := 1
+ for j + 1 < len(source) && depth > 0 {
+ if source[j] == '{' && source[j + 1] == '{' {
+ depth += 1
+ j += 2
+ } else if source[j] == '}' && source[j + 1] == '}' {
+ depth -= 1
+ j += 2
+ } else {
+ j += 1
+ }
+ }
+ tag_end := j
+ if pos >= tag_start && pos < tag_end {
+ return line_start, tag_start, tag_end
+ }
+ i = tag_end
+ } else {
+ i += 1
+ }
+ }
+
+ // Not inside a tag — underline a single rune at pos.
+ return line_start, pos, pos + 1
+}
+
+// should_colorize returns true if stderr is a TTY and color output is wanted.
+should_colorize :: proc() -> bool {
+ return os.is_tty(os.stderr)
+}
+
+// count_lines returns the number of '\n'-separated lines in source.
+// A trailing newline does not add an extra line.
+count_lines :: proc(source: string) -> int {
+ if len(source) == 0 {
+ return 1
+ }
+ n := 1
+ for c in source {
+ if c == '\n' {
+ n += 1
+ }
+ }
+ // Drop phantom last line if source ends with '\n'.
+ if len(source) > 0 && source[len(source) - 1] == '\n' {
+ n -= 1
+ }
+ return n
+}
+
+// digit_count returns the number of decimal digits in n (min 1).
+digit_count :: proc(n: int) -> int {
+ if n <= 0 {
+ return 1
+ }
+ c := 0
+ x := n
+ for x > 0 {
+ c += 1
+ x /= 10
+ }
+ return c
+}
+
+// display_width returns the number of terminal cells `s` occupies.
+// For ASCII this is byte length; for UTF-8 we count runes (combining
+// marks and wide CJK chars are still approximate).
+display_width :: proc(s: string) -> int {
+ return utf8.rune_count_in_string(s)
+}
+
+// format_error produces a rust-style multi-line diagnostic string.
+//
+//
+// --> ::
+// |
+// N |
+// N |
+// N |
+// | ^^^^^^^^^^^
+// N |
+// N |
+// |
+//
+// `context_before`/`context_after` lines of context are shown around the
+// error line. Line numbers are right-aligned to the width of the largest
+// line number shown.
+format_error :: proc(
+ path: string,
+ source: string,
+ pos: int,
+ msg: string,
+ hint: string = "",
+ context_before: int = 2,
+ context_after: int = 2,
+ colorize: bool = false,
+) -> string {
+ line, col := line_col(source, pos)
+ total_lines := count_lines(source)
+
+ start_line := line - context_before
+ if start_line < 1 {
+ start_line = 1
+ }
+ end_line := line + context_after
+ if end_line > total_lines {
+ end_line = total_lines
+ }
+
+ // Width of the line-number column (right-align).
+ width := digit_count(end_line)
+ if width < 1 {
+ width = 1
+ }
+
+ sb := strings.builder_make(context.temp_allocator)
+ defer strings.builder_destroy(&sb)
+
+ color := colorize
+ red, faint, reset := "", "", ""
+ if color {
+ red = ansi.CSI + ansi.FG_RED + ansi.SGR
+ faint = ansi.CSI + ansi.FAINT + ansi.SGR
+ reset = ansi.CSI + ansi.RESET + ansi.SGR
+ }
+
+ // Header line: message.
+ strings.write_string(&sb, msg)
+ strings.write_byte(&sb, '\n')
+
+ // Location line: " --> path:line:col" (width spaces + arrow).
+ strings.write_string(&sb, faint)
+ for _ in 0 ..< width {
+ strings.write_byte(&sb, ' ')
+ }
+ strings.write_string(&sb, "--> ")
+ strings.write_string(&sb, reset)
+ strings.write_string(&sb, fmt.tprintf("%s:%d:%d\n", path, line, col))
+
+ // Top gutter line.
+ write_gutter(&sb, width, faint, reset)
+
+ // Caret extent for the error line.
+ _, token_start, token_end := context_extent(source, pos)
+ line_start, _, _ := context_extent(source, pos)
+ caret_start_col := token_start - line_start + 1
+ caret_end_col := token_end - line_start + 1
+ if caret_end_col <= caret_start_col {
+ caret_end_col = caret_start_col + 1
+ }
+
+ // Context lines.
+ for n in start_line ..= end_line {
+ // Line number (right-aligned, faint).
+ num_str := fmt.tprintf("%d", n)
+ strings.write_string(&sb, faint)
+ for _ in 0 ..< width - len(num_str) {
+ strings.write_byte(&sb, ' ')
+ }
+ strings.write_string(&sb, num_str)
+ strings.write_string(&sb, " | ")
+ strings.write_string(&sb, reset)
+
+ strings.write_string(&sb, line_text(source, n))
+ strings.write_byte(&sb, '\n')
+
+ // After the error line, emit the caret row.
+ if n == line {
+ strings.write_string(&sb, faint)
+ for _ in 0 ..< width + 1 {
+ strings.write_byte(&sb, ' ')
+ }
+ strings.write_string(&sb, "| ")
+ strings.write_string(&sb, reset)
+
+ for _ in 1 ..< caret_start_col {
+ strings.write_byte(&sb, ' ')
+ }
+ if color {
+ strings.write_string(&sb, red)
+ }
+ for _ in 0 ..< caret_end_col - caret_start_col {
+ strings.write_byte(&sb, '^')
+ }
+ if color {
+ strings.write_string(&sb, reset)
+ }
+ if hint != "" {
+ strings.write_byte(&sb, ' ')
+ if color {
+ strings.write_string(&sb, faint)
+ }
+ strings.write_string(&sb, hint)
+ if color {
+ strings.write_string(&sb, reset)
+ }
+ }
+ strings.write_byte(&sb, '\n')
+ }
+ }
+
+ // Trailing gutter line for visual closure.
+ write_gutter(&sb, width, faint, reset)
+
+ return strings.to_string(sb)
+}
+
+// write_gutter emits a faint pipe-only gutter line: ` |`.
+write_gutter :: proc(sb: ^strings.Builder, width: int, faint: string, reset: string) {
+ strings.write_string(sb, faint)
+ for _ in 0 ..< width + 1 {
+ strings.write_byte(sb, ' ')
+ }
+ strings.write_string(sb, "|")
+ strings.write_string(sb, reset)
+ strings.write_byte(sb, '\n')
+}
+
+// format_render_error dispatches on Render_Error variant and produces a
+// diagnostic for it. Returns "" for nil errors.
+format_render_error :: proc(err: Render_Error, tmpl: Template, colorize: bool = false) -> string {
+ if err == nil {
+ return ""
+ }
+ switch e in err {
+ case Syntax_Error:
+ path := tmpl.path
+ if path == "" {
+ path = ""
+ }
+ return format_error(path, tmpl.source, e.pos, e.msg, colorize = colorize)
+ case Data_Error:
+ path := tmpl.path
+ if path == "" {
+ path = ""
+ }
+ return format_error(path, tmpl.source, e.pos, e.msg, colorize = colorize)
+ }
+ return ""
+}
+
diff --git a/mustache/diagnostic_test.odin b/mustache/diagnostic_test.odin
new file mode 100644
index 0000000..7d9ae39
--- /dev/null
+++ b/mustache/diagnostic_test.odin
@@ -0,0 +1,576 @@
+#+test
+package mustache
+
+import "core:fmt"
+import "core:strings"
+import "core:testing"
+
+// ---------------------------------------------------------------------------
+// line_col / line_text / count_lines / digit_count — primitive helpers
+// ---------------------------------------------------------------------------
+
+@(test)
+test_line_col_basic :: proc(t: ^testing.T) {
+ src := "abc\ndef\nghi"
+ cases := [?]struct {
+ pos: int,
+ line: int,
+ col: int,
+ }{{0, 1, 1}, {2, 1, 3}, {3, 1, 4}, {4, 2, 1}, {6, 2, 3}, {7, 2, 4}, {8, 3, 1}}
+ for c in cases {
+ l, col := line_col(src, c.pos)
+ testing.expect(t, l == c.line, fmt.tprintf("pos %d: line %d, want %d", c.pos, l, c.line))
+ testing.expect(t, col == c.col, fmt.tprintf("pos %d: col %d, want %d", c.pos, col, c.col))
+ }
+}
+
+@(test)
+test_line_col_empty :: proc(t: ^testing.T) {
+ l, col := line_col("", 0)
+ testing.expect_value(t, l, 1)
+ testing.expect_value(t, col, 1)
+}
+
+@(test)
+test_line_col_negative :: proc(t: ^testing.T) {
+ l, col := line_col("abc", -1)
+ testing.expect_value(t, l, 1)
+ testing.expect_value(t, col, 1)
+}
+
+@(test)
+test_line_col_past_end :: proc(t: ^testing.T) {
+ l, col := line_col("abc", 100)
+ testing.expect_value(t, l, 1)
+ testing.expect_value(t, col, 4)
+}
+
+@(test)
+test_line_text_first :: proc(t: ^testing.T) {
+ src := "first\nsecond\nthird"
+ testing.expect_value(t, line_text(src, 1), "first")
+ testing.expect_value(t, line_text(src, 2), "second")
+ testing.expect_value(t, line_text(src, 3), "third")
+}
+
+@(test)
+test_line_text_trailing_newline :: proc(t: ^testing.T) {
+ src := "first\nsecond\n"
+ testing.expect_value(t, line_text(src, 1), "first")
+ testing.expect_value(t, line_text(src, 2), "second")
+ testing.expect_value(t, line_text(src, 3), "")
+}
+
+@(test)
+test_line_text_out_of_range :: proc(t: ^testing.T) {
+ testing.expect_value(t, line_text("abc", 5), "")
+ testing.expect_value(t, line_text("abc", 0), "")
+}
+
+@(test)
+test_count_lines :: proc(t: ^testing.T) {
+ testing.expect_value(t, count_lines(""), 1)
+ testing.expect_value(t, count_lines("abc"), 1)
+ testing.expect_value(t, count_lines("a\nb"), 2)
+ testing.expect_value(t, count_lines("a\nb\n"), 2)
+ testing.expect_value(t, count_lines("a\nb\nc"), 3)
+}
+
+@(test)
+test_digit_count :: proc(t: ^testing.T) {
+ testing.expect_value(t, digit_count(0), 1)
+ testing.expect_value(t, digit_count(1), 1)
+ testing.expect_value(t, digit_count(9), 1)
+ testing.expect_value(t, digit_count(10), 2)
+ testing.expect_value(t, digit_count(99), 2)
+ testing.expect_value(t, digit_count(100), 3)
+ testing.expect_value(t, digit_count(-5), 1)
+}
+
+// ---------------------------------------------------------------------------
+// format_error — golden output tests
+// ---------------------------------------------------------------------------
+
+@(test)
+test_format_error_basic :: proc(t: ^testing.T) {
+ src := "line 1\nline 2\n{{bad}}\nline 4\nline 5"
+ out := format_error("p.html", src, 14, "unknown key 'bad'", "", colorize = false)
+ expected := `unknown key 'bad'
+ --> p.html:3:1
+ |
+1 | line 1
+2 | line 2
+3 | {{bad}}
+ | ^^^^^^^
+4 | line 4
+5 | line 5
+ |
+`
+ testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_with_hint :: proc(t: ^testing.T) {
+ src := "line 1\nline 2\n{{titel}}\nline 4\nline 5"
+ out := format_error(
+ "post.html",
+ src,
+ 14,
+ "unknown key 'titel'",
+ "did you mean 'title'?",
+ colorize = false,
+ )
+ expected := `unknown key 'titel'
+ --> post.html:3:1
+ |
+1 | line 1
+2 | line 2
+3 | {{titel}}
+ | ^^^^^^^^^ did you mean 'title'?
+4 | line 4
+5 | line 5
+ |
+`
+ testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_no_hint_omits_trailing_space :: proc(t: ^testing.T) {
+ src := "{{bad}}"
+ out := format_error("p.html", src, 0, "msg", "", colorize = false)
+ // Caret line ends immediately after the carets — no trailing space.
+ testing.expect(t, strings.contains(out, "^^^^^^^\n"), out)
+ testing.expect(t, !strings.contains(out, "^^^^^^^ \n"), out)
+}
+
+// ---------------------------------------------------------------------------
+// Edge cases — context window clamping
+// ---------------------------------------------------------------------------
+
+@(test)
+test_format_error_first_line_only_after_context :: proc(t: ^testing.T) {
+ src := "{{bad}}\nline 2\nline 3\nline 4\nline 5"
+ out := format_error("p.html", src, 0, "msg", "", colorize = false)
+ expected := `msg
+ --> p.html:1:1
+ |
+1 | {{bad}}
+ | ^^^^^^^
+2 | line 2
+3 | line 3
+ |
+`
+ testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_last_line_only_before_context :: proc(t: ^testing.T) {
+ src := "line 1\nline 2\nline 3\nline 4\n{{bad}}"
+ out := format_error("p.html", src, 28, "msg", "", colorize = false)
+ expected := `msg
+ --> p.html:5:1
+ |
+3 | line 3
+4 | line 4
+5 | {{bad}}
+ | ^^^^^^^
+ |
+`
+ testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_short_source_clamped :: proc(t: ^testing.T) {
+ src := "x\n{{bad}}\ny"
+ out := format_error("p.html", src, 2, "msg", "", colorize = false)
+ expected := `msg
+ --> p.html:2:1
+ |
+1 | x
+2 | {{bad}}
+ | ^^^^^^^
+3 | y
+ |
+`
+ testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_single_line_source :: proc(t: ^testing.T) {
+ src := "{{bad}}"
+ out := format_error("p.html", src, 0, "msg", "", colorize = false)
+ expected := `msg
+ --> p.html:1:1
+ |
+1 | {{bad}}
+ | ^^^^^^^
+ |
+`
+ testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_two_digit_line_numbers :: proc(t: ^testing.T) {
+ // 12-line source; error on line 9. end_line=11 → width=2.
+ src := "l01\nl02\nl03\nl04\nl05\nl06\nl07\nl08\n{{bad}}\nl10\nl11\nl12"
+ // Position of `{{bad}}`: 8 lines of "l0N\n" = 8*4 = 32 bytes.
+ out := format_error("p.html", src, 32, "msg", "", colorize = false)
+ testing.expect(t, strings.contains(out, " --> p.html:9:1\n"), out)
+ testing.expect(t, strings.contains(out, " |\n"), out)
+ testing.expect(t, strings.contains(out, " 7 | l07\n"), out)
+ testing.expect(t, strings.contains(out, " 9 | {{bad}}\n"), out)
+ testing.expect(t, strings.contains(out, "11 | l11\n"), out)
+}
+
+@(test)
+test_format_error_three_digit_line_numbers :: proc(t: ^testing.T) {
+ // 102-line source; error on line 100. Width=3 because end_line=102 has 3 digits.
+ parts: [dynamic]string
+ defer delete(parts)
+ for i in 1 ..= 99 {
+ append(&parts, fmt.tprintf("l%03d", i))
+ }
+ append(&parts, "{{bad}}")
+ append(&parts, "l101")
+ append(&parts, "l102")
+ src := strings.join(parts[:], "\n", context.temp_allocator)
+
+ // Find byte position of "{{bad}}": after 99 lines.
+ pos := 0
+ for i in 1 ..= 99 {
+ pos += len(parts[i - 1]) + 1
+ }
+
+ out := format_error("p.html", src, pos, "msg", "", colorize = false)
+ testing.expect(t, strings.contains(out, " --> p.html:100:1\n"), out)
+ testing.expect(t, strings.contains(out, " |\n"), out)
+ testing.expect(t, strings.contains(out, " 98 | l098\n"), out)
+ testing.expect(t, strings.contains(out, "100 | {{bad}}\n"), out)
+ testing.expect(t, strings.contains(out, "102 | l102\n"), out)
+}
+
+// ---------------------------------------------------------------------------
+// Caret position
+// ---------------------------------------------------------------------------
+
+@(test)
+test_caret_at_column_1 :: proc(t: ^testing.T) {
+ src := "{{bad}} at start"
+ out := format_error("p.html", src, 0, "msg", "", colorize = false)
+ // Caret line should start with "^" right after "| " (no leading spaces).
+ testing.expect(t, strings.contains(out, " | ^^^^^^^\n"), out)
+}
+
+@(test)
+test_caret_at_column_N :: proc(t: ^testing.T) {
+ src := " {{bad}}"
+ // pos=4 is the first '{'. Line 1, col 5.
+ out := format_error("p.html", src, 4, "msg", "", colorize = false)
+ // 4 leading spaces, then 7 carets.
+ testing.expect(t, strings.contains(out, " | ^^^^^^^\n"), out)
+}
+
+@(test)
+test_caret_width_matches_token :: proc(t: ^testing.T) {
+ src := "{{x}}"
+ out := format_error("p.html", src, 0, "msg", "", colorize = false)
+ // {{x}} is 5 chars wide.
+ testing.expect(t, strings.contains(out, " | ^^^^^\n"), out)
+}
+
+// ---------------------------------------------------------------------------
+// Context count
+// ---------------------------------------------------------------------------
+
+@(test)
+test_context_before_zero :: proc(t: ^testing.T) {
+ src := "l1\nl2\nl3\n{{bad}}\nl5\nl6"
+ out := format_error(
+ "p.html",
+ src,
+ 9,
+ "msg",
+ "",
+ context_before = 0,
+ context_after = 1,
+ colorize = false,
+ )
+ expected := `msg
+ --> p.html:4:1
+ |
+4 | {{bad}}
+ | ^^^^^^^
+5 | l5
+ |
+`
+ testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_context_after_zero :: proc(t: ^testing.T) {
+ src := "l1\nl2\nl3\n{{bad}}\nl5\nl6"
+ out := format_error(
+ "p.html",
+ src,
+ 9,
+ "msg",
+ "",
+ context_before = 1,
+ context_after = 0,
+ colorize = false,
+ )
+ expected := `msg
+ --> p.html:4:1
+ |
+3 | l3
+4 | {{bad}}
+ | ^^^^^^^
+ |
+`
+ testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_context_both_zero :: proc(t: ^testing.T) {
+ src := "l1\nl2\nl3\n{{bad}}\nl5\nl6"
+ out := format_error(
+ "p.html",
+ src,
+ 9,
+ "msg",
+ "",
+ context_before = 0,
+ context_after = 0,
+ colorize = false,
+ )
+ expected := `msg
+ --> p.html:4:1
+ |
+4 | {{bad}}
+ | ^^^^^^^
+ |
+`
+ testing.expect_value(t, out, expected)
+}
+
+// ---------------------------------------------------------------------------
+// Gutter/alignment
+// ---------------------------------------------------------------------------
+
+@(test)
+test_gutter_pipes_align_with_source_pipe :: proc(t: ^testing.T) {
+ src := "l1\n{{bad}}\nl3"
+ out := format_error("p.html", src, 3, "msg", "", colorize = false)
+ // All "|" characters should appear at the same column.
+ // For width=1: source line is "N | ...", so "|" at col 2.
+ // Empty gutter is " |" (width+1 spaces + "|"), so "|" at col 2.
+ lines := strings.split(out, "\n", context.temp_allocator)
+ defer delete(lines)
+ pipe_col := -1
+ for line in lines {
+ idx := strings.index(line, "|")
+ if idx < 0 {
+ continue
+ }
+ if pipe_col < 0 {
+ pipe_col = idx
+ } else {
+ testing.expect_value(t, idx, pipe_col)
+ }
+ }
+}
+
+@(test)
+test_arrow_points_at_pipe :: proc(t: ^testing.T) {
+ src := "{{bad}}"
+ out := format_error("p.html", src, 0, "msg", "", colorize = false)
+ // For width=1: arrow line is " --> ..." so ">" at col 3.
+ // Pipe lines are " |" so "|" at col 2.
+ lines := strings.split(out, "\n", context.temp_allocator)
+ defer delete(lines)
+
+ pipe_col := -1
+ for line in lines {
+ idx := strings.index(line, "|")
+ if idx >= 0 {
+ pipe_col = idx
+ break
+ }
+ }
+ testing.expect(t, pipe_col >= 0, "expected pipe in output")
+
+ // Find the arrow line specifically and verify its ">" column.
+ arrow_col := -1
+ for line in lines {
+ idx := strings.index(line, "-->")
+ if idx >= 0 {
+ arrow_col = idx + 2 // ">" is the last char of "-->"
+ break
+ }
+ }
+ testing.expect(t, arrow_col >= 0, "expected --> in output")
+ testing.expect_value(t, arrow_col, pipe_col + 1)
+}
+
+// ---------------------------------------------------------------------------
+// format_render_error — dispatch
+// ---------------------------------------------------------------------------
+
+@(test)
+test_format_render_error_dispatch :: proc(t: ^testing.T) {
+ src := "{{#unclosed}}\ncontent"
+ tmpl, parse_err := parse(src, "test.html")
+ testing.expect(t, parse_err != nil, "should fail to parse unclosed section")
+ if parse_err == nil {
+ return
+ }
+
+ #partial switch e in parse_err {
+ case Syntax_Error:
+ out := format_error("test.html", src, e.pos, e.msg, colorize = false)
+ testing.expect(t, strings.contains(out, "unclosed section"), out)
+ testing.expect(t, strings.contains(out, "test.html:"), out)
+ }
+}
+
+@(test)
+test_diagnostic_for_pipe_error :: proc(t: ^testing.T) {
+ src := "{{#name | group_by year}}x{{/name}}"
+ tmpl, perr := parse(src, "test.html")
+ testing.expect(t, perr == nil, "should parse")
+ if perr != nil {
+ return
+ }
+ defer delete_template(&tmpl)
+
+ Data :: struct {
+ name: string,
+ }
+ _, rerr := render(tmpl, Data{name = "hello"})
+ testing.expect(t, rerr != nil, "should fail to render")
+ if rerr == nil {
+ return
+ }
+
+ out := format_render_error(rerr, tmpl, colorize = false)
+ testing.expect(t, strings.contains(out, "group_by expects a list"), out)
+ testing.expect(t, strings.contains(out, "test.html:"), out)
+}
+
+// ---------------------------------------------------------------------------
+// Parser error messages preserve double braces in tag syntax
+// ---------------------------------------------------------------------------
+
+@(test)
+test_parse_error_expected_got_keeps_double_braces :: proc(t: ^testing.T) {
+ src := "{{#content}}body{{/cotent}}"
+ _, err := parse(src, "test.html")
+ testing.expect(t, err != nil, "should fail to parse")
+ if err == nil {
+ return
+ }
+ #partial switch e in err {
+ case Syntax_Error:
+ testing.expect(
+ t,
+ strings.contains(e.msg, "{{/content}}"),
+ fmt.tprintf("msg should contain literal {{/content}}, got %q", e.msg),
+ )
+ testing.expect(
+ t,
+ strings.contains(e.msg, "{{/cotent}}"),
+ fmt.tprintf("msg should contain literal {{/cotent}}, got %q", e.msg),
+ )
+ }
+}
+
+@(test)
+test_parse_error_unclosed_section_keeps_double_braces :: proc(t: ^testing.T) {
+ src := "{{#content}}body"
+ _, err := parse(src, "test.html")
+ testing.expect(t, err != nil, "should fail to parse")
+ if err == nil {
+ return
+ }
+ #partial switch e in err {
+ case Syntax_Error:
+ testing.expect(
+ t,
+ strings.contains(e.msg, "{{#content}}"),
+ fmt.tprintf("msg should contain literal {{#content}}, got %q", e.msg),
+ )
+ }
+}
+
+@(test)
+test_parse_error_unexpected_close_keeps_double_braces :: proc(t: ^testing.T) {
+ src := "text{{/content}}"
+ _, err := parse(src, "test.html")
+ testing.expect(t, err != nil, "should fail to parse")
+ if err == nil {
+ return
+ }
+ #partial switch e in err {
+ case Syntax_Error:
+ testing.expect(
+ t,
+ strings.contains(e.msg, "{{/content}}"),
+ fmt.tprintf("msg should contain literal {{/content}}, got %q", e.msg),
+ )
+ }
+}
+
+@(test)
+test_parse_error_pipe_in_close_tag_keeps_double_braces :: proc(t: ^testing.T) {
+ src := "{{#posts | group_by year}}x{{/posts | group_by year}}"
+ _, err := parse(src, "test.html")
+ testing.expect(t, err != nil, "should fail to parse")
+ if err == nil {
+ return
+ }
+ #partial switch e in err {
+ case Syntax_Error:
+ testing.expect(
+ t,
+ strings.contains(e.msg, "{{/"),
+ fmt.tprintf("msg should contain literal '{{/', got %q", e.msg),
+ )
+ }
+}
+
+@(test)
+test_parse_error_pipe_parse_in_section_keeps_double_braces :: proc(t: ^testing.T) {
+ src := "{{#posts |}}x{{/posts}}"
+ _, err := parse(src, "test.html")
+ testing.expect(t, err != nil, "should fail to parse")
+ if err == nil {
+ return
+ }
+ #partial switch e in err {
+ case Syntax_Error:
+ testing.expect(
+ t,
+ strings.contains(e.msg, "{{#"),
+ fmt.tprintf("msg should contain literal '{{#', got %q", e.msg),
+ )
+ }
+}
+
+@(test)
+test_parse_error_pipe_parse_in_inverted_keeps_double_braces :: proc(t: ^testing.T) {
+ src := "{{^posts |}}x{{/posts}}"
+ _, err := parse(src, "test.html")
+ testing.expect(t, err != nil, "should fail to parse")
+ if err == nil {
+ return
+ }
+ #partial switch e in err {
+ case Syntax_Error:
+ testing.expect(
+ t,
+ strings.contains(e.msg, "{{^"),
+ fmt.tprintf("msg should contain literal '{{^', got %q", e.msg),
+ )
+ }
+}
+
diff --git a/mustache/mustache.odin b/mustache/mustache.odin
index 58b1ef5..b1963aa 100644
--- a/mustache/mustache.odin
+++ b/mustache/mustache.odin
@@ -1,28 +1,27 @@
package mustache
import "core:fmt"
+import "core:log"
import "core:strings"
// ---------------------------------------------------------------------------
// Error types
// ---------------------------------------------------------------------------
+// TODO: I don't think this is the best way to do our errors.
Syntax_Error :: struct {
msg: string,
pos: int,
}
+
Data_Error :: struct {
msg: string,
-}
-Partial_Error :: struct {
- name: string,
- msg: string,
+ pos: int,
}
Render_Error :: union {
Syntax_Error,
Data_Error,
- Partial_Error,
}
// ---------------------------------------------------------------------------
@@ -50,6 +49,7 @@ Node :: struct {
first_child: int,
child_count: int,
content: string,
+ pos: int,
}
// node_span returns the number of flat-array entries a node occupies:
@@ -67,12 +67,14 @@ node_span :: proc(n: Node) -> int {
Template :: struct {
nodes: [dynamic]Node,
source: string,
+ path: string,
}
Block_Override :: struct {
all_nodes: []Node,
first: int,
count: int,
+ source: Template,
}
delete_template :: proc(tmpl: ^Template) {
@@ -94,6 +96,7 @@ delete_partials :: proc(partials: map[string]Template) {
parse :: proc(
source: string,
+ path := "",
allocator := context.allocator,
tokens_allocator := context.temp_allocator,
) -> (
@@ -111,6 +114,7 @@ parse :: proc(
return {}, err
}
tmpl.source = source
+ tmpl.path = path
deindent_blocks(tmpl.nodes[:], 0, len(tmpl.nodes), allocator)
return tmpl, nil
}
@@ -133,7 +137,7 @@ render :: proc(
append(&ctx, data)
all_nodes := tmpl.nodes[:]
- err = render_nodes(all_nodes, all_nodes, &ctx, partials, &builder)
+ err = render_nodes(tmpl, all_nodes, all_nodes, &ctx, partials, &builder)
if err != nil {
return result, err
}
@@ -158,7 +162,7 @@ parse_tokens :: proc(
) {
nodes = make([dynamic]Node, 0, len(tokens), allocator)
pos := 0
- err = parse_section(tokens, &pos, &nodes, "", source, allocator)
+ err = parse_section(tokens, &pos, &nodes, "", source, allocator, 0)
return
}
@@ -169,22 +173,23 @@ parse_section :: proc(
end_tag: string,
source: string,
allocator := context.allocator,
+ open_pos: int = 0,
) -> Render_Error {
for pos^ < len(tokens) {
tok := tokens[pos^]
switch tok.kind {
case .Text:
- append(nodes, Node{kind = .Text, text = tok.value, first_child = -1})
+ append(nodes, Node{kind = .Text, text = tok.value, first_child = -1, pos = tok.pos})
pos^ += 1
case .Variable:
idx := len(nodes)
append(nodes, Node{kind = .Variable, first_child = -1})
- pipe_key, perr := parse_pipeline(tok.value, &nodes[idx].filters)
+ pipe_key, perr := parse_pipeline(tok.value, &nodes[idx].filters, tok.pos)
if perr != nil {
return Syntax_Error {
- msg = fmt.tprintf("pipe parse error in '{{%s}}': %v", tok.value, perr),
+ msg = fmt.tprintf("pipe parse error in '{{{{%s}}}}': %v", tok.value, perr),
pos = tok.pos,
}
}
@@ -194,10 +199,10 @@ parse_section :: proc(
case .Unescaped:
idx := len(nodes)
append(nodes, Node{kind = .Unescaped, first_child = -1})
- pipe_key, perr := parse_pipeline(tok.value, &nodes[idx].filters)
+ pipe_key, perr := parse_pipeline(tok.value, &nodes[idx].filters, tok.pos)
if perr != nil {
return Syntax_Error {
- msg = fmt.tprintf("pipe parse error in '{{&%s}}': %v", tok.value, perr),
+ msg = fmt.tprintf("pipe parse error in '{{{{&%s}}}}': %v", tok.value, perr),
pos = tok.pos,
}
}
@@ -212,16 +217,16 @@ parse_section :: proc(
idx := len(nodes)
content_start := 0
if pos^ < len(tokens) {content_start = tokens[pos^].pos}
- append(nodes, Node{kind = .Section, first_child = -1})
- pipe_key, perr := parse_pipeline(tok.value, &nodes[idx].filters)
+ append(nodes, Node{kind = .Section, first_child = -1, pos = tok.pos})
+ pipe_key, perr := parse_pipeline(tok.value, &nodes[idx].filters, tok.pos)
if perr != nil {
return Syntax_Error {
- msg = fmt.tprintf("pipe parse error in '{{#%s}}': %v", tok.value, perr),
+ msg = fmt.tprintf("pipe parse error in '{{{{#%s}}}}': %v", tok.value, perr),
pos = tok.pos,
}
}
nodes[idx].key = pipe_key
- parse_section(tokens, pos, nodes, pipe_key, source, allocator) or_return
+ parse_section(tokens, pos, nodes, pipe_key, source, allocator, tok.pos) or_return
close_pos := 0
if pos^ - 1 >= 0 && pos^ - 1 < len(tokens) {close_pos = tokens[pos^ - 1].pos}
nodes[idx].first_child = idx + 1
@@ -233,16 +238,16 @@ parse_section :: proc(
idx := len(nodes)
content_start := 0
if pos^ < len(tokens) {content_start = tokens[pos^].pos}
- append(nodes, Node{kind = .Inverted, first_child = -1})
- pipe_key, perr := parse_pipeline(tok.value, &nodes[idx].filters)
+ append(nodes, Node{kind = .Inverted, first_child = -1, pos = tok.pos})
+ pipe_key, perr := parse_pipeline(tok.value, &nodes[idx].filters, tok.pos)
if perr != nil {
return Syntax_Error {
- msg = fmt.tprintf("pipe parse error in '{{^%s}}': %v", tok.value, perr),
+ msg = fmt.tprintf("pipe parse error in '{{{{^%s}}}}': %v", tok.value, perr),
pos = tok.pos,
}
}
nodes[idx].key = pipe_key
- parse_section(tokens, pos, nodes, pipe_key, source, allocator) or_return
+ parse_section(tokens, pos, nodes, pipe_key, source, allocator, tok.pos) or_return
close_pos := 0
if pos^ - 1 >= 0 && pos^ - 1 < len(tokens) {close_pos = tokens[pos^ - 1].pos}
nodes[idx].first_child = idx + 1
@@ -253,7 +258,7 @@ parse_section :: proc(
if strings.contains(tok.value, "|") {
return Syntax_Error {
msg = fmt.tprintf(
- "pipe expression not allowed in close tag '{{/%s}}' — use the bare key",
+ "pipe expression not allowed in close tag '{{{{/%s}}}}' — use the bare key",
tok.value,
),
pos = tok.pos,
@@ -265,12 +270,12 @@ parse_section :: proc(
}
if end_tag == "" {
return Syntax_Error {
- msg = fmt.tprintf("unexpected {{/%s}}", tok.value),
+ msg = fmt.tprintf("unexpected {{{{/%s}}}}", tok.value),
pos = tok.pos,
}
}
return Syntax_Error {
- msg = fmt.tprintf("expected {{/%s}}, got {{/%s}}", end_tag, tok.value),
+ msg = fmt.tprintf("expected {{{{/%s}}}}, got {{{{/%s}}}}", end_tag, tok.value),
pos = tok.pos,
}
@@ -283,6 +288,7 @@ parse_section :: proc(
is_dynamic = tok.is_dynamic,
indent = tok.indent,
first_child = -1,
+ pos = tok.pos,
},
)
pos^ += 1
@@ -292,9 +298,15 @@ parse_section :: proc(
idx := len(nodes)
append(
nodes,
- Node{kind = .Parent, key = tok.value, indent = tok.indent, first_child = -1},
+ Node {
+ kind = .Parent,
+ key = tok.value,
+ indent = tok.indent,
+ first_child = -1,
+ pos = tok.pos,
+ },
)
- parse_section(tokens, pos, nodes, tok.value, source, allocator) or_return
+ parse_section(tokens, pos, nodes, tok.value, source, allocator, tok.pos) or_return
nodes[idx].first_child = idx + 1
nodes[idx].child_count = len(nodes) - idx - 1
@@ -303,16 +315,25 @@ parse_section :: proc(
idx := len(nodes)
append(
nodes,
- Node{kind = .Block, key = tok.value, indent = tok.indent, first_child = -1},
+ Node {
+ kind = .Block,
+ key = tok.value,
+ indent = tok.indent,
+ first_child = -1,
+ pos = tok.pos,
+ },
)
- parse_section(tokens, pos, nodes, tok.value, source, allocator) or_return
+ parse_section(tokens, pos, nodes, tok.value, source, allocator, tok.pos) or_return
nodes[idx].first_child = idx + 1
nodes[idx].child_count = len(nodes) - idx - 1
}
}
if end_tag != "" {
- return Syntax_Error{msg = fmt.tprintf("unclosed section '{{#%s}}'", end_tag)}
+ return Syntax_Error {
+ msg = fmt.tprintf("unclosed section '{{{{#%s}}}}'", end_tag),
+ pos = open_pos,
+ }
}
return nil
}
@@ -476,11 +497,20 @@ render_template :: proc(
indent: string,
) -> Render_Error {
if len(indent) > 0 && len(pt.source) > 0 {
+ // Per Mustache spec: the partial's source is indented before rendering,
+ // not its output. This is necessary so that data-injected newlines
+ // (e.g. from `{{{content}}}` where content contains `\n`) do NOT pick
+ // up the indent — only source-level line breaks do.
indented := indent_lines(pt.source, indent)
- reparse := parse(indented, context.temp_allocator, context.temp_allocator) or_return
- return render_nodes(reparse.nodes[:], reparse.nodes[:], ctx, partials, b, blocks)
+ reparse := parse(
+ indented,
+ pt.path,
+ context.temp_allocator,
+ context.temp_allocator,
+ ) or_return
+ return render_nodes(reparse, reparse.nodes[:], reparse.nodes[:], ctx, partials, b, blocks)
}
- return render_nodes(pt.nodes[:], pt.nodes[:], ctx, partials, b, blocks)
+ return render_nodes(pt, pt.nodes[:], pt.nodes[:], ctx, partials, b, blocks)
}
// ---------------------------------------------------------------------------
@@ -488,6 +518,7 @@ render_template :: proc(
// ---------------------------------------------------------------------------
render_nodes :: proc(
+ current: Template,
all_nodes: []Node,
nodes: []Node,
ctx: ^[dynamic]any,
@@ -505,19 +536,28 @@ render_nodes :: proc(
case .Variable:
val := resolve_name(node.key, ctx[:])
+ if val == nil {
+ warn_unknown_key(current, ctx[:], node)
+ }
if len(node.filters) > 0 {
- transformed, perr := apply_pipeline(val, node.filters[:])
+ transformed, perr := apply_pipeline(val, node.filters[:], node.pos)
if perr != nil {
return perr
}
val = transformed
}
if result_str, ok := call_interp_lambda(val); ok {
- sub_tpl, perr := parse(result_str, context.temp_allocator, context.temp_allocator)
+ sub_tpl, perr := parse(
+ result_str,
+ fmt.tprintf("", node.key),
+ context.temp_allocator,
+ context.temp_allocator,
+ )
if perr == nil {
temp: strings.Builder
strings.builder_init(&temp, context.temp_allocator)
render_nodes(
+ sub_tpl,
sub_tpl.nodes[:],
sub_tpl.nodes[:],
ctx,
@@ -534,19 +574,28 @@ render_nodes :: proc(
case .Unescaped:
val := resolve_name(node.key, ctx[:])
+ if val == nil {
+ warn_unknown_key(current, ctx[:], node)
+ }
if len(node.filters) > 0 {
- transformed, perr := apply_pipeline(val, node.filters[:])
+ transformed, perr := apply_pipeline(val, node.filters[:], node.pos)
if perr != nil {
return perr
}
val = transformed
}
if result_str, ok := call_interp_lambda(val); ok {
- sub_tpl, perr := parse(result_str, context.temp_allocator, context.temp_allocator)
+ sub_tpl, perr := parse(
+ result_str,
+ fmt.tprintf("", node.key),
+ context.temp_allocator,
+ context.temp_allocator,
+ )
if perr == nil {
temp: strings.Builder
strings.builder_init(&temp, context.temp_allocator)
render_nodes(
+ sub_tpl,
sub_tpl.nodes[:],
sub_tpl.nodes[:],
ctx,
@@ -563,17 +612,26 @@ render_nodes :: proc(
case .Section:
val := resolve_name(node.key, ctx[:])
+ if val == nil {
+ warn_unknown_key(current, ctx[:], node)
+ }
if len(node.filters) > 0 {
- transformed, perr := apply_pipeline(val, node.filters[:])
+ transformed, perr := apply_pipeline(val, node.filters[:], node.pos)
if perr != nil {
return perr
}
val = transformed
}
if result_str, ok := call_section_lambda(val, node.content); ok {
- sub_tpl, perr := parse(result_str, context.temp_allocator, context.temp_allocator)
+ sub_tpl, perr := parse(
+ result_str,
+ fmt.tprintf("", node.key),
+ context.temp_allocator,
+ context.temp_allocator,
+ )
if perr == nil {
render_nodes(
+ sub_tpl,
sub_tpl.nodes[:],
sub_tpl.nodes[:],
ctx,
@@ -590,20 +648,31 @@ render_nodes :: proc(
elem := extract_list_element(elem_info, data, j)
append(ctx, elem)
defer pop(ctx)
- render_nodes(all_nodes, children, ctx, partials, b, blocks) or_return
+ render_nodes(
+ current,
+ all_nodes,
+ children,
+ ctx,
+ partials,
+ b,
+ blocks,
+ ) or_return
}
} else {
append(ctx, val)
defer pop(ctx)
- render_nodes(all_nodes, children, ctx, partials, b, blocks) or_return
+ render_nodes(current, all_nodes, children, ctx, partials, b, blocks) or_return
}
}
i += 1 + node.child_count
case .Inverted:
val := resolve_name(node.key, ctx[:])
+ if val == nil {
+ warn_unknown_key(current, ctx[:], node)
+ }
if len(node.filters) > 0 {
- transformed, perr := apply_pipeline(val, node.filters[:])
+ transformed, perr := apply_pipeline(val, node.filters[:], node.pos)
if perr != nil {
return perr
}
@@ -611,7 +680,7 @@ render_nodes :: proc(
}
if !is_truthy(val) {
children := all_nodes[node.first_child:node.first_child + node.child_count]
- render_nodes(all_nodes, children, ctx, partials, b, blocks) or_return
+ render_nodes(current, all_nodes, children, ctx, partials, b, blocks) or_return
}
i += 1 + node.child_count
@@ -622,7 +691,9 @@ render_nodes :: proc(
name = any_to_string(val)
}
pt, found := partials[name]
- if found {
+ if !found {
+ warn_missing_partial(current, partials, node, name)
+ } else {
render_template(pt, ctx, partials, b, nil, node.indent) or_return
}
i += 1
@@ -631,6 +702,7 @@ render_nodes :: proc(
content_nodes: []Node
content_pool: []Node
content_blocks := blocks
+ render_current := current
found_override := false
if blocks != nil {
@@ -638,6 +710,7 @@ render_nodes :: proc(
content_nodes = o.all_nodes[o.first:o.first + o.count]
content_pool = o.all_nodes
found_override = true
+ render_current = o.source
}
}
if !found_override {
@@ -649,6 +722,7 @@ render_nodes :: proc(
temp: strings.Builder
strings.builder_init(&temp, context.temp_allocator)
render_nodes(
+ render_current,
content_pool,
content_nodes,
ctx,
@@ -659,6 +733,7 @@ render_nodes :: proc(
write_indented(b, node.indent, strings.to_string(temp))
} else {
render_nodes(
+ render_current,
content_pool,
content_nodes,
ctx,
@@ -671,9 +746,12 @@ render_nodes :: proc(
case .Parent:
parent_children := all_nodes[node.first_child:node.first_child + node.child_count]
- merged := merge_block_overrides(parent_children, all_nodes, blocks)
+ merged := merge_block_overrides(parent_children, all_nodes, blocks, current)
pt, found := partials[node.key]
- if found {
+ if !found {
+ warn_missing_partial(current, partials, node, node.key)
+ } else {
+ warn_unmatched_block_overrides(current, pt, parent_children)
render_template(pt, ctx, partials, b, merged, node.indent) or_return
}
i += 1 + node.child_count
@@ -686,6 +764,7 @@ merge_block_overrides :: proc(
children: []Node,
all_nodes: []Node,
existing: map[string]Block_Override,
+ source: Template,
) -> map[string]Block_Override {
result := make(map[string]Block_Override, context.temp_allocator)
@@ -702,6 +781,7 @@ merge_block_overrides :: proc(
all_nodes = all_nodes,
first = child.first_child,
count = child.child_count,
+ source = source,
}
}
}
@@ -711,3 +791,115 @@ merge_block_overrides :: proc(
return result
}
+// warn_unknown_key checks whether the missing key is a genuine typo (vs. a
+// legitimate path through a user-defined map) and, if so, emits a diagnostic
+// warning with the closest field-name suggestion via Levenshtein.
+warn_unknown_key :: proc(current: Template, ctx: []any, node: Node) {
+ // `{{.}}` and dot-prefixed names refer to the current context — always valid.
+ if node.key == "." || (len(node.key) > 0 && node.key[0] == '.') {
+ return
+ }
+
+ path_ok, missing, available := validate_key_path(ctx, node.key)
+ if path_ok {
+ return
+ }
+
+ hint := ""
+ if len(available) > 0 {
+ suggestion := suggest_correction(available, missing)
+ if suggestion != "" {
+ hint = fmt.tprintf("did you mean '%s'?", suggestion)
+ }
+ }
+ msg := fmt.tprintf("unknown key '%s'", node.key)
+ path := current.path
+ if path == "" {
+ path = ""
+ }
+ diag := format_error(path, current.source, node.pos, msg, hint, colorize = should_colorize())
+ log.warnf("%s", diag)
+}
+
+// warn_missing_partial emits a warning when a `{{> name}}` or `{{",
+ context.allocator,
+ mem.dynamic_arena_allocator(&arena),
+ )
testing.expect(t, err == nil)
defer delete_template(&tmpl)
}
diff --git a/mustache/pipes.odin b/mustache/pipes.odin
index 2c90b91..1f794fe 100644
--- a/mustache/pipes.odin
+++ b/mustache/pipes.odin
@@ -27,6 +27,7 @@ Group :: struct {
parse_pipeline :: proc(
content: string,
filters_out: ^[dynamic; MAX_PIPES]Pipe_Filter,
+ pos: int,
) -> (
key: string,
err: Render_Error,
@@ -46,12 +47,13 @@ parse_pipeline :: proc(
filter_count,
MAX_PIPES,
),
+ pos = pos,
}
}
key = strings.trim_space(segments[0])
if len(key) == 0 {
- return "", Syntax_Error{msg = "pipe expression missing key"}
+ return "", Syntax_Error{msg = "pipe expression missing key", pos = pos}
}
if filter_count == 0 {
@@ -61,12 +63,12 @@ parse_pipeline :: proc(
for i in 0 ..< filter_count {
seg := strings.trim_space(segments[i + 1])
if len(seg) == 0 {
- return "", Syntax_Error{msg = "empty filter"}
+ return "", Syntax_Error{msg = "empty filter", pos = pos}
}
tokens := strings.fields(seg)
if len(tokens) == 0 {
- return "", Syntax_Error{msg = "filter missing op name"}
+ return "", Syntax_Error{msg = "filter missing op name", pos = pos}
}
arg_count := len(tokens) - 1
@@ -78,6 +80,7 @@ parse_pipeline :: proc(
arg_count,
MAX_PIPE_ARGS,
),
+ pos = pos,
}
}
@@ -94,10 +97,10 @@ parse_pipeline :: proc(
return key, nil
}
-apply_pipeline :: proc(value: any, filters: []Pipe_Filter) -> (any, Render_Error) {
+apply_pipeline :: proc(value: any, filters: []Pipe_Filter, pos: int) -> (any, Render_Error) {
current := value
for &filter in filters {
- result, err := apply_filter(current, &filter)
+ result, err := apply_filter(current, &filter, pos)
if err != nil {
return nil, err
}
@@ -106,19 +109,22 @@ apply_pipeline :: proc(value: any, filters: []Pipe_Filter) -> (any, Render_Error
return current, nil
}
-apply_filter :: proc(value: any, filter: ^Pipe_Filter) -> (any, Render_Error) {
+apply_filter :: proc(value: any, filter: ^Pipe_Filter, pos: int) -> (any, Render_Error) {
switch filter.op {
case "group_by":
- return apply_group_by(value, filter.args[:])
+ return apply_group_by(value, filter.args[:], pos)
case "format":
str, ok := reflect.as_string(value)
if !ok {
- return value, Data_Error{msg = "format may only be used on dates"}
+ return value, Data_Error{msg = "format may only be used on dates", pos = pos}
} else {
- return apply_format(str, filter.args[:])
+ return apply_format(str, filter.args[:], pos)
}
case:
- return nil, Data_Error{msg = fmt.tprintf("unknown pipe op '%s'", filter.op)}
+ return nil, Data_Error{
+ msg = fmt.tprintf("unknown pipe op '%s'", filter.op),
+ pos = pos,
+ }
}
}
@@ -138,9 +144,9 @@ apply_filter :: proc(value: any, filter: ^Pipe_Filter) -> (any, Render_Error) {
// 2023-10-15T13:18:50Z
// 2023-10-15T13:18:50
// 2023-10-15
-apply_format :: proc(iso: string, args: []string) -> (result: any, err: Render_Error) {
+apply_format :: proc(iso: string, args: []string, pos: int) -> (result: any, err: Render_Error) {
if len(iso) < 10 {
- return nil, Data_Error{msg = "format may only be used on dates"}
+ return nil, Data_Error{msg = "format may only be used on dates", pos = pos}
}
year := iso[:4]
@@ -148,7 +154,7 @@ apply_format :: proc(iso: string, args: []string) -> (result: any, err: Render_E
day_num := (int(iso[8]) - 0x30) * 10 + (int(iso[9]) - 0x30)
if month_num < 1 || month_num > 12 {
- return nil, Data_Error{msg = fmt.tprintf("invalid date: \"%s\"", iso)}
+ return nil, Data_Error{msg = fmt.tprintf("invalid date: \"%s\"", iso), pos = pos}
}
month := fmt.tprintf("%s", time.Month(month_num))[:3]
@@ -156,15 +162,21 @@ apply_format :: proc(iso: string, args: []string) -> (result: any, err: Render_E
}
// Groups preserve first-appearance order from the input list.
-apply_group_by :: proc(value: any, args: []string) -> (result: any, err: Render_Error) {
+apply_group_by :: proc(value: any, args: []string, pos: int) -> (result: any, err: Render_Error) {
if len(args) != 1 {
- return nil, Data_Error{msg = fmt.tprintf("group_by expects 1 argument, got %d", len(args))}
+ return nil, Data_Error{
+ msg = fmt.tprintf("group_by expects 1 argument, got %d", len(args)),
+ pos = pos,
+ }
}
field := args[0]
elem_info, count, data := list_info(value)
if elem_info == nil {
- return nil, Data_Error{msg = "group_by expects a list"}
+ return nil, Data_Error{
+ msg = "group_by expects a list",
+ pos = pos,
+ }
}
groups := make([dynamic]Group, 0, 8, context.temp_allocator)
@@ -179,11 +191,15 @@ apply_group_by :: proc(value: any, args: []string) -> (result: any, err: Render_
if !found {
return nil, Data_Error {
msg = fmt.tprintf("group_by: element missing field '%s'", field),
+ pos = pos,
}
}
key_str := any_to_string(key_val)
if len(key_str) == 0 {
- return nil, Data_Error{msg = fmt.tprintf("group_by: field '%s' is empty", field)}
+ return nil, Data_Error{
+ msg = fmt.tprintf("group_by: field '%s' is empty", field),
+ pos = pos,
+ }
}
idx, exists := key_to_idx[key_str]
diff --git a/mustache/pipes_test.odin b/mustache/pipes_test.odin
index d8f1342..31d284f 100644
--- a/mustache/pipes_test.odin
+++ b/mustache/pipes_test.odin
@@ -216,7 +216,7 @@ test_interp_pipe_basic :: proc(t: ^testing.T) {
data := Scalar_Data {
name = "2026-03-15T08:49:54-04:00",
}
- tpl, _ := parse("[{{name | format}}]", context.temp_allocator)
+ tpl, _ := parse("[{{name | format}}]", "", allocator = context.temp_allocator)
result, _ := render(tpl, data, {}, context.temp_allocator)
testing.expect_value(t, result, "[15 Mar 2026]")
}
@@ -229,7 +229,7 @@ test_interp_pipe_unescaped :: proc(t: ^testing.T) {
data := Scalar_Data {
name = "2025-12-25T00:00:00Z",
}
- tpl, _ := parse("[{{&name | format}}]", context.temp_allocator)
+ tpl, _ := parse("[{{&name | format}}]", "", allocator = context.temp_allocator)
result, _ := render(tpl, data, {}, context.temp_allocator)
testing.expect_value(t, result, "[25 Dec 2025]")
}
@@ -242,7 +242,7 @@ test_interp_pipe_dot_current :: proc(t: ^testing.T) {
data := List_Data {
items = {"2026-01-06T00:00:00Z", "2026-06-15T00:00:00Z", "2026-10-15T00:00:00Z"},
}
- tpl, _ := parse("{{#items}}[{{. | format}}]{{/items}}", context.temp_allocator)
+ tpl, _ := parse("{{#items}}[{{. | format}}]{{/items}}", "", allocator = context.temp_allocator)
result, _ := render(tpl, data, {}, context.temp_allocator)
testing.expect_value(t, result, "[6 Jan 2026][15 Jun 2026][15 Oct 2026]")
}
@@ -260,7 +260,7 @@ test_format_typical_iso :: proc(t: ^testing.T) {
data := Format_Data {
date = "2026-03-15T08:49:54-04:00",
}
- tpl, _ := parse("{{date | format}}", context.temp_allocator)
+ tpl, _ := parse("{{date | format}}", "", allocator = context.temp_allocator)
result, _ := render(tpl, data, {}, context.temp_allocator)
testing.expect_value(t, result, "15 Mar 2026")
}
@@ -270,7 +270,7 @@ test_format_short_date_only :: proc(t: ^testing.T) {
data := Format_Data {
date = "2026-06-06",
}
- tpl, _ := parse("{{date | format}}", context.temp_allocator)
+ tpl, _ := parse("{{date | format}}", "", allocator = context.temp_allocator)
result, _ := render(tpl, data, {}, context.temp_allocator)
testing.expect_value(t, result, "6 Jun 2026")
}
@@ -280,7 +280,7 @@ test_format_empty_input_errors :: proc(t: ^testing.T) {
data := Format_Data {
date = "",
}
- tpl, _ := parse("[{{date | format}}]", context.temp_allocator)
+ tpl, _ := parse("[{{date | format}}]", "", allocator = context.temp_allocator)
defer delete_template(&tpl)
_, err := render(tpl, data, {}, context.temp_allocator)
testing.expect(t, err != nil, "empty date should error")
@@ -291,7 +291,7 @@ test_format_non_date_string_errors :: proc(t: ^testing.T) {
data := Format_Data {
date = "abc",
}
- tpl, _ := parse("[{{date | format}}]", context.temp_allocator)
+ tpl, _ := parse("[{{date | format}}]", "", allocator = context.temp_allocator)
defer delete_template(&tpl)
_, err := render(tpl, data, {}, context.temp_allocator)
testing.expect(t, err != nil, "non-date string should error")
@@ -305,7 +305,7 @@ test_format_non_string_value_errors :: proc(t: ^testing.T) {
data := Int_Data {
count = 42,
}
- tpl, _ := parse("{{count | format}}", context.temp_allocator)
+ tpl, _ := parse("{{count | format}}", "", allocator = context.temp_allocator)
defer delete_template(&tpl)
_, err := render(tpl, data, {}, context.temp_allocator)
testing.expect(t, err != nil, "non-string value should error")
@@ -316,7 +316,7 @@ test_format_invalid_month_errors :: proc(t: ^testing.T) {
data := Format_Data {
date = "2023-13-15",
}
- tpl, _ := parse("{{date | format}}", context.temp_allocator)
+ tpl, _ := parse("{{date | format}}", "", allocator = context.temp_allocator)
defer delete_template(&tpl)
_, err := render(tpl, data, {}, context.temp_allocator)
testing.expect(t, err != nil, "invalid month should error")
@@ -331,7 +331,8 @@ test_format_inside_section_renders :: proc(t: ^testing.T) {
}
tpl, _ := parse(
"{{#date}}{{/date}}",
- context.temp_allocator,
+ "",
+ allocator = context.temp_allocator,
)
result, _ := render(tpl, data, {}, context.temp_allocator)
testing.expect_value(t, result, "")
@@ -342,7 +343,7 @@ test_format_inside_section_skips_when_empty :: proc(t: ^testing.T) {
data := Format_Data {
date = "",
}
- tpl, _ := parse("[{{#date}}{{/date}}]", context.temp_allocator)
+ tpl, _ := parse("[{{#date}}{{/date}}]", "", allocator = context.temp_allocator)
result, _ := render(tpl, data, {}, context.temp_allocator)
testing.expect_value(t, result, "[]")
}
@@ -362,7 +363,7 @@ test_format_handles_all_iso8601_variants :: proc(t: ^testing.T) {
data := Format_Data {
date = c.input,
}
- tpl, _ := parse("{{date | format}}", context.temp_allocator)
+ tpl, _ := parse("{{date | format}}", "", allocator = context.temp_allocator)
result, _ := render(tpl, data, {}, context.temp_allocator)
testing.expect_value(t, result, c.expected)
}
diff --git a/mustache/spec_test.odin b/mustache/spec_test.odin
index 92e1bea..6cc8655 100644
--- a/mustache/spec_test.odin
+++ b/mustache/spec_test.odin
@@ -3,6 +3,7 @@ package mustache
import "core:encoding/json"
import "core:fmt"
+import "core:log"
import "core:os"
import "core:path/filepath"
import "core:testing"
@@ -54,6 +55,10 @@ run_one_test :: proc(
test: json.Object,
name, template_src, expected: string,
) -> bool {
+ // Spec tests deliberately exercise missing keys, missing partials, etc.
+ // Silence the warnings to keep test output readable.
+ context.logger = log.nil_logger()
+
partials := make_map(map[string]Template, context.temp_allocator)
if "partials" in test {
@@ -63,7 +68,7 @@ run_one_test :: proc(
psrc, ok := pval.(string)
assert(ok)
- pt, perr := parse(psrc, context.temp_allocator)
+ pt, perr := parse(psrc, "", context.temp_allocator)
if perr != nil {
testing.expectf(t, false, "[%s] partial '%s' parse error", name, pname)
return false
@@ -72,7 +77,7 @@ run_one_test :: proc(
}
}
- tmpl, terr := parse(template_src, context.temp_allocator)
+ tmpl, terr := parse(template_src, "", context.temp_allocator)
if terr != nil {
testing.expectf(t, false, "[%s] template parse error", name)
return false
diff --git a/mustache/suggest.odin b/mustache/suggest.odin
new file mode 100644
index 0000000..1b91b69
--- /dev/null
+++ b/mustache/suggest.odin
@@ -0,0 +1,206 @@
+package mustache
+
+import "base:runtime"
+import "core:strings"
+
+// collect_struct_keys enumerates the visible field names of a struct value,
+// including fields promoted via `using`-embedded structs.
+collect_struct_keys :: proc(val: any, allocator := context.temp_allocator) -> []string {
+ out: [dynamic]string
+ collect_struct_keys_into(val, &out, allocator)
+ return out[:]
+}
+
+collect_struct_keys_into :: proc(val: any, out: ^[dynamic]string, allocator := context.allocator) {
+ v, info := base_value(val)
+ if info == nil {
+ return
+ }
+ s, ok := info.variant.(runtime.Type_Info_Struct)
+ if !ok {
+ return
+ }
+ for i in 0 ..< int(s.field_count) {
+ name := s.names[i]
+ if len(name) == 0 {
+ continue
+ }
+ if name[0] == '_' {
+ continue
+ }
+ append(out, name)
+
+ // Recurse into using-embedded struct fields to surface promoted names.
+ if s.usings[i] {
+ field_info := type_info_of(s.types[i].id)
+ if field_info != nil {
+ collect_struct_keys_into(any{v.data, s.types[i].id}, out, allocator)
+ }
+ }
+ }
+}
+
+// struct_has_field reports whether a struct value has a named field,
+// independent of whether that field's value is currently nil. This matters
+// for fields like `Maybe(bool)` which can be nil but still exist.
+struct_has_field :: proc(val: any, key: string) -> bool {
+ v, info := base_value(val)
+ if info == nil {
+ return false
+ }
+ s, ok := info.variant.(runtime.Type_Info_Struct)
+ if !ok {
+ return false
+ }
+ for i in 0 ..< int(s.field_count) {
+ if s.names[i] == key {
+ return true
+ }
+ // Recurse into using-embedded fields.
+ if s.usings[i] {
+ if struct_has_field(any{v.data, s.types[i].id}, key) {
+ return true
+ }
+ }
+ }
+ return false
+}
+
+// validate_key_path walks a dotted key path against the context stack and
+// reports where (if anywhere) the lookup fails. Returns:
+// - ok: true if the entire path resolves, OR if the path crosses a map
+// (map keys are user-defined and not validated)
+// - missing_segment: the segment that failed (empty when ok)
+// - available: keys available at the failing level, for suggestions
+validate_key_path :: proc(
+ ctx: []any,
+ key: string,
+ allocator := context.temp_allocator,
+) -> (
+ ok: bool,
+ missing_segment: string,
+ available: []string,
+) {
+ parts: [16]string
+ part_count := 0
+ start := 0
+ for i in 0 ..< len(key) {
+ if key[i] == '.' {
+ if part_count < len(parts) {
+ parts[part_count] = key[start:i]
+ part_count += 1
+ }
+ start = i + 1
+ }
+ }
+ if part_count < len(parts) {
+ parts[part_count] = key[start:]
+ part_count += 1
+ }
+ if part_count == 0 {
+ return true, "", nil
+ }
+
+ current: any = nil
+ found := false
+ for i := len(ctx) - 1; i >= 0; i -= 1 {
+ current, found = lookup_in(ctx[i], parts[0])
+ if found {
+ break
+ }
+ }
+
+ if !found {
+ keys: [dynamic]string
+ for i := len(ctx) - 1; i >= 0; i -= 1 {
+ collect_struct_keys_into(ctx[i], &keys, allocator)
+ }
+ return false, parts[0], keys[:]
+ }
+
+ for i in 1 ..< part_count {
+ v, info := base_value(current)
+ if info == nil {
+ return false, parts[i], nil
+ }
+ if _, is_map := info.variant.(runtime.Type_Info_Map); is_map {
+ return true, "", nil
+ }
+ if _, is_struct := info.variant.(runtime.Type_Info_Struct); is_struct {
+ if !struct_has_field(current, parts[i]) {
+ return false, parts[i], collect_struct_keys(current, allocator)
+ }
+ // Field exists — descend into it. If the value is nil, stop here
+ // (further segments can't be resolved but the current field is
+ // legitimately present).
+ next, found := lookup_in(current, parts[i])
+ if !found {
+ return true, "", nil
+ }
+ current = next
+ continue
+ }
+ return false, parts[i], nil
+ }
+
+ return true, "", nil
+}
+
+// suggest_correction returns the closest match from `available` to `missing`
+// using Levenshtein distance, or "" if no good match exists. The threshold
+// scales with the length of the missing key.
+suggest_correction :: proc(available: []string, missing: string) -> string {
+ if len(available) == 0 || len(missing) == 0 {
+ return ""
+ }
+ threshold := 2
+ if len(missing) > 8 {
+ threshold = len(missing) / 4
+ }
+
+ best: string
+ best_dist := threshold + 1
+ for candidate in available {
+ if abs(len(candidate) - len(missing)) > threshold {
+ continue
+ }
+ d := strings.levenshtein_distance(missing, candidate)
+ if d <= threshold && d < best_dist {
+ best = candidate
+ best_dist = d
+ }
+ }
+ return best
+}
+
+// collect_partial_names enumerates the keys of the partials map.
+collect_partial_names :: proc(
+ partials: map[string]Template,
+ allocator := context.temp_allocator,
+) -> []string {
+ out: [dynamic]string
+ for name in partials {
+ append(&out, name)
+ }
+ return out[:]
+}
+
+// collect_block_names enumerates the unique `{{$name}}` block definitions in
+// a template's node array.
+collect_block_names :: proc(
+ tmpl: Template,
+ allocator := context.temp_allocator,
+) -> []string {
+ out: [dynamic]string
+ seen := make(map[string]bool, allocator)
+ defer delete(seen)
+ for &node in tmpl.nodes {
+ if node.kind == .Block {
+ if !seen[node.key] {
+ seen[node.key] = true
+ append(&out, node.key)
+ }
+ }
+ }
+ return out[:]
+}
diff --git a/mustache/suggest_test.odin b/mustache/suggest_test.odin
new file mode 100644
index 0000000..d42dd2f
--- /dev/null
+++ b/mustache/suggest_test.odin
@@ -0,0 +1,194 @@
+#+test
+#+feature dynamic-literals
+package mustache
+
+import "core:fmt"
+import "core:testing"
+
+Inner :: struct {
+ foo: string,
+ bar: int,
+}
+
+Outer :: struct {
+ title: string,
+ page_title: string,
+ inner: Inner,
+ numbers: [3]int,
+}
+
+@(test)
+test_validate_simple_found :: proc(t: ^testing.T) {
+ data := Outer {
+ title = "hi",
+ }
+ ctx := make([dynamic]any, 0, 1, context.temp_allocator)
+ append(&ctx, data)
+
+ ok, missing, _ := validate_key_path(ctx[:], "title")
+ testing.expect_value(t, ok, true)
+ testing.expect(t, missing == "", fmt.tprintf("expected empty missing, got %q", missing))
+}
+
+@(test)
+test_validate_simple_missing :: proc(t: ^testing.T) {
+ data := Outer {
+ title = "hi",
+ }
+ ctx := make([dynamic]any, 0, 1, context.temp_allocator)
+ append(&ctx, data)
+
+ ok, missing, available := validate_key_path(ctx[:], "page_titel")
+ testing.expect_value(t, ok, false)
+ testing.expect_value(t, missing, "page_titel")
+ testing.expect(t, len(available) > 0, "should have suggestions")
+}
+
+@(test)
+test_validate_dotted_found :: proc(t: ^testing.T) {
+ data := Outer {
+ inner = Inner{foo = "x"},
+ }
+ ctx := make([dynamic]any, 0, 1, context.temp_allocator)
+ append(&ctx, data)
+
+ ok, missing, _ := validate_key_path(ctx[:], "inner.foo")
+ testing.expect_value(t, ok, true)
+ testing.expect_value(t, missing, "")
+}
+
+@(test)
+test_validate_dotted_missing :: proc(t: ^testing.T) {
+ data := Outer {
+ inner = Inner{foo = "x"},
+ }
+ ctx := make([dynamic]any, 0, 1, context.temp_allocator)
+ append(&ctx, data)
+
+ ok, missing, available := validate_key_path(ctx[:], "inner.fooo")
+ testing.expect_value(t, ok, false)
+ testing.expect_value(t, missing, "fooo")
+ testing.expect(t, len(available) > 0, "should have inner field suggestions")
+}
+
+Params_Data :: struct {
+ params: map[string]string,
+}
+
+Maybe_Bool_Data :: struct {
+ flag: Maybe(bool),
+ name: string,
+}
+
+Inner_For_Using :: struct {
+ flag: Maybe(bool),
+ label: string,
+}
+
+Outer_With_Using :: struct {
+ using inner: Inner_For_Using,
+ other: int,
+}
+
+@(test)
+test_validate_path_through_using_to_maybe_bool :: proc(t: ^testing.T) {
+ data := Outer_With_Using {
+ inner = Inner_For_Using{label = "hi"},
+ other = 42,
+ }
+ ctx := make([dynamic]any, 0, 1, context.temp_allocator)
+ append(&ctx, data)
+
+ // `flag` is promoted via using; field exists even when Maybe is nil.
+ ok, missing, _ := validate_key_path(ctx[:], "flag")
+ testing.expect_value(t, ok, true)
+ testing.expect_value(t, missing, "")
+
+ // `label` is also promoted via using.
+ ok2, missing2, _ := validate_key_path(ctx[:], "label")
+ testing.expect_value(t, ok2, true)
+ testing.expect_value(t, missing2, "")
+}
+
+@(test)
+test_struct_has_field_with_maybe_bool :: proc(t: ^testing.T) {
+ data := Maybe_Bool_Data {
+ name = "hi",
+ } // flag is nil Maybe
+ testing.expect_value(t, struct_has_field(data, "flag"), true)
+ testing.expect_value(t, struct_has_field(data, "name"), true)
+ testing.expect_value(t, struct_has_field(data, "missing"), false)
+}
+
+@(test)
+test_validate_path_through_maybe_bool :: proc(t: ^testing.T) {
+ data := Maybe_Bool_Data {
+ name = "hi",
+ }
+ ctx := make([dynamic]any, 0, 1, context.temp_allocator)
+ append(&ctx, data)
+
+ // `flag` exists as a field even when its Maybe value is nil — should NOT warn.
+ ok, missing, _ := validate_key_path(ctx[:], "flag")
+ testing.expect_value(t, ok, true)
+ testing.expect_value(t, missing, "")
+}
+
+@(test)
+test_validate_map_path_silent :: proc(t: ^testing.T) {
+ data := Params_Data {
+ params = {"social" = "x"},
+ }
+ ctx := make([dynamic]any, 0, 1, context.temp_allocator)
+ append(&ctx, data)
+
+ // `params` exists and is a map — subsequent segments are user-defined.
+ ok, _, _ := validate_key_path(ctx[:], "params.anything_here")
+ testing.expect_value(t, ok, true)
+}
+
+@(test)
+test_suggest_correction_exact :: proc(t: ^testing.T) {
+ available := []string{"title", "page_title", "body"}
+ testing.expect_value(t, suggest_correction(available, "page_titel"), "page_title")
+}
+
+@(test)
+test_suggest_correction_close :: proc(t: ^testing.T) {
+ available := []string{"title", "body", "now"}
+ testing.expect_value(t, suggest_correction(available, "titel"), "title")
+}
+
+@(test)
+test_suggest_correction_no_match :: proc(t: ^testing.T) {
+ available := []string{"completely_different", "unrelated"}
+ testing.expect_value(t, suggest_correction(available, "page_titel"), "")
+}
+
+@(test)
+test_suggest_correction_empty :: proc(t: ^testing.T) {
+ testing.expect_value(t, suggest_correction([]string{}, "anything"), "")
+ testing.expect_value(t, suggest_correction([]string{"a"}, ""), "")
+}
+
+@(test)
+test_warn_no_false_positive_for_valid_keys :: proc(t: ^testing.T) {
+ Data :: struct {
+ name: string,
+ }
+ src := "Hello {{name}}"
+ tmpl, err := parse(src, "", context.temp_allocator)
+ testing.expect(t, err == nil, "should parse")
+ if err != nil {
+ return
+ }
+
+ // We can't easily capture log output in tests, but we can verify the
+ // validation procs agree the key exists.
+ ctx := make([dynamic]any, 0, 1, context.temp_allocator)
+ append(&ctx, Data{name = "World"})
+
+ ok, missing, _ := validate_key_path(ctx[:], "name")
+ testing.expect_value(t, ok, true)
+}
+
diff --git a/render.odin b/render.odin
index c53cb7d..103cf6e 100644
--- a/render.odin
+++ b/render.odin
@@ -55,14 +55,40 @@ build_page_context :: proc(page: Page) -> Page_Context {
}
load_template :: proc(vfs: ^VFS, virtual_path: string) -> mustache.Template {
- data, ok := vfs_get(vfs, virtual_path)
+ entry, data, ok := vfs_get_entry(vfs, virtual_path)
if !ok {
- log.warnf("template %s not found", virtual_path)
- return mustache.Template{}
+ log.fatalf("template %s not found", virtual_path)
+ os.exit(1)
}
- tpl, err := mustache.parse(string(data))
+ source := string(data)
+ tpl, err := mustache.parse(source, entry.fs_path)
if err != nil {
- log.warnf("failed to parse template %s: %v", virtual_path, err)
+ switch e in err {
+ // TODO: Find a way to merge these branches.
+ case mustache.Syntax_Error:
+ log.errorf(
+ "%s",
+ mustache.format_error(
+ entry.fs_path,
+ source,
+ e.pos,
+ e.msg,
+ colorize = mustache.should_colorize(),
+ ),
+ )
+ case mustache.Data_Error:
+ log.errorf(
+ "%s",
+ mustache.format_error(
+ entry.fs_path,
+ source,
+ e.pos,
+ e.msg,
+ colorize = mustache.should_colorize(),
+ ),
+ )
+ }
+ os.exit(1)
}
return tpl
}
@@ -122,7 +148,10 @@ render_template :: proc(
) -> string {
result, err := mustache.render(content_tpl, data, partials)
if err != nil {
- fmt.eprintfln("mustache error: %v", err)
+ log.errorf(
+ "%s",
+ mustache.format_render_error(err, content_tpl, colorize = mustache.should_colorize()),
+ )
return ""
}
return result
@@ -331,7 +360,7 @@ render_section :: proc(
load_partials :: proc(vfs: ^VFS) -> map[string]mustache.Template {
partials: map[string]mustache.Template
prefix := "layouts/partials/"
- for virtual_path in vfs.files {
+ for virtual_path, entry in vfs.files {
if !strings.has_prefix(virtual_path, prefix) {
continue
}
@@ -342,14 +371,36 @@ load_partials :: proc(vfs: ^VFS) -> map[string]mustache.Template {
stripped := virtual_path[len(prefix):]
key := stripped[:len(stripped) - len(".html")]
- data, ok := vfs_get(vfs, virtual_path)
- if !ok {
- continue
- }
- tpl, err := mustache.parse(string(data))
+ data := vfs_entry_data(entry) or_continue
+ source := string(data)
+ tpl, err := mustache.parse(source, entry.fs_path)
if err != nil {
- log.warnf("failed to parse partial %s: %v", key, err)
- continue
+ // TODO: Find a way to merge these branches.
+ switch e in err {
+ case mustache.Syntax_Error:
+ log.errorf(
+ "%s",
+ mustache.format_error(
+ entry.fs_path,
+ source,
+ e.pos,
+ e.msg,
+ colorize = mustache.should_colorize(),
+ ),
+ )
+ case mustache.Data_Error:
+ log.errorf(
+ "%s",
+ mustache.format_error(
+ entry.fs_path,
+ source,
+ e.pos,
+ e.msg,
+ colorize = mustache.should_colorize(),
+ ),
+ )
+ }
+ os.exit(1)
}
partials[key] = tpl
}
diff --git a/vfs.odin b/vfs.odin
index 51ce374..e565b46 100644
--- a/vfs.odin
+++ b/vfs.odin
@@ -78,3 +78,35 @@ vfs_get :: proc(vfs: ^VFS, virtual_path: string) -> ([]byte, bool) {
return data, true
}
+// vfs_get_entry returns both the VFS_Entry (for fs_path) and the lazily-loaded
+// data. Use this instead of vfs_get when you need the entry's metadata along
+// with the contents.
+vfs_get_entry :: proc(vfs: ^VFS, virtual_path: string) -> (VFS_Entry, []byte, bool) {
+ entry, ok := vfs.files[virtual_path]
+ if !ok {
+ return {}, nil, false
+ }
+ if entry.data != nil {
+ return entry, entry.data, true
+ }
+ data, err := os.read_entire_file_from_path(entry.fs_path, context.allocator)
+ if err != nil {
+ return entry, nil, false
+ }
+ return entry, data, true
+}
+
+// vfs_entry_data returns the data for a VFS_Entry, reading from disk if it
+// hasn't been loaded yet. Useful when iterating vfs.files directly (where you
+// already have the entry and don't want a redundant map lookup).
+vfs_entry_data :: proc(entry: VFS_Entry) -> ([]byte, bool) {
+ if entry.data != nil {
+ return entry.data, true
+ }
+ data, err := os.read_entire_file_from_path(entry.fs_path, context.allocator)
+ if err != nil {
+ return nil, false
+ }
+ return data, true
+}
+