mirror of
https://github.com/sbrow/thor.git
synced 2026-08-26 11:23:32 -04:00
feat: Added Rust-style error messages for template errors.
This commit is contained in:
Spencer Brower
@@ -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
|
||||
<time datetime="{{date}}">{{date | format}}</time>
|
||||
```
|
||||
|
||||
Currently implemented: `group_by <field>` (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 <field>` (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**: `{{<parent}}` loads parent from partials, `{{$block}}` defines overridable sections. `merge_block_overrides` propagates overrides through multi-level chains.
|
||||
- **Dynamic partial names**: `{{>*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 (`{{<name}}` not in partials map)
|
||||
- Unmatched block overrides (`{{$name}}` doesn't match any block in parent template)
|
||||
|
||||
**Exceptions** (no warning):
|
||||
- `{{.}}` and dot-prefixed names (current context)
|
||||
- Paths that cross a map (e.g., `params.*` — user-defined namespace)
|
||||
- `Maybe(bool)` fields with nil value (field exists, value is nil — distinguished via `struct_has_field`)
|
||||
|
||||
**Block override source tracking**: `Block_Override.source: Template` ensures warnings inside block overrides point at the override's source file (e.g., `page.html`), not the parent template (`base.html`).
|
||||
|
||||
### Lambdas
|
||||
|
||||
Spec-compliant. Stored as `any` values in the data context.
|
||||
@@ -353,11 +399,17 @@ Spec-compliant. Stored as `any` values in the data context.
|
||||
|
||||
### Pipes
|
||||
|
||||
`{{#key | op args…}}…{{/key}}`. Stored as `[dynamic; MAX_PIPES]Pipe_Filter` on each `Node` (fixed-cap inline storage, no per-tag heap allocation at parse time). Applied in the renderer via `apply_pipeline` before truthiness check. Currently only `group_by <field>` 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 <field>` — 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
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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.
|
||||
//
|
||||
// <msg>
|
||||
// --> <path>:<line>:<col>
|
||||
// |
|
||||
// N | <source line N-2>
|
||||
// N | <source line N-1>
|
||||
// N | <source line N — the error line>
|
||||
// | ^^^^^^^^^^^ <hint>
|
||||
// N | <source line N+1>
|
||||
// N | <source line N+2>
|
||||
// |
|
||||
//
|
||||
// `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: `<width+1 spaces> |`.
|
||||
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 = "<input>"
|
||||
}
|
||||
return format_error(path, tmpl.source, e.pos, e.msg, colorize = colorize)
|
||||
case Data_Error:
|
||||
path := tmpl.path
|
||||
if path == "" {
|
||||
path = "<input>"
|
||||
}
|
||||
return format_error(path, tmpl.source, e.pos, e.msg, colorize = colorize)
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
@@ -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),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
+236
-44
@@ -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("<lambda output from '%s'>", 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("<lambda output from '%s'>", 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("<lambda output from '%s'>", 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 = "<input>"
|
||||
}
|
||||
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 `{{<name}}` tag
|
||||
// references a partial that isn't in the partials map.
|
||||
warn_missing_partial :: proc(
|
||||
current: Template,
|
||||
partials: map[string]Template,
|
||||
node: Node,
|
||||
name: string,
|
||||
) {
|
||||
hint := ""
|
||||
available := collect_partial_names(partials)
|
||||
defer delete(available)
|
||||
suggestion := suggest_correction(available, name)
|
||||
if suggestion != "" {
|
||||
hint = fmt.tprintf("did you mean '%s'?", suggestion)
|
||||
}
|
||||
msg := fmt.tprintf("partial '%s' not found", name)
|
||||
path := current.path
|
||||
if path == "" {
|
||||
path = "<input>"
|
||||
}
|
||||
diag := format_error(path, current.source, node.pos, msg, hint, colorize = should_colorize())
|
||||
log.warnf("%s", diag)
|
||||
}
|
||||
|
||||
// warn_unmatched_block_overrides checks each `{{$name}}...{{/name}}` block
|
||||
// defined inside a `{{<parent}}` tag and warns when the name doesn't match
|
||||
// any block in the parent template.
|
||||
warn_unmatched_block_overrides :: proc(
|
||||
current: Template,
|
||||
parent: Template,
|
||||
parent_children: []Node,
|
||||
) {
|
||||
if len(parent_children) == 0 {
|
||||
return
|
||||
}
|
||||
available := collect_block_names(parent)
|
||||
defer delete(available)
|
||||
parent_path := parent.path
|
||||
if parent_path == "" {
|
||||
parent_path = "<input>"
|
||||
}
|
||||
for child in parent_children {
|
||||
if child.kind != .Block {
|
||||
continue
|
||||
}
|
||||
matched := false
|
||||
for name in available {
|
||||
if name == child.key {
|
||||
matched = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if matched {
|
||||
continue
|
||||
}
|
||||
|
||||
hint := ""
|
||||
suggestion := suggest_correction(available, child.key)
|
||||
if suggestion != "" {
|
||||
hint = fmt.tprintf("did you mean '%s'?", suggestion)
|
||||
}
|
||||
msg := fmt.tprintf(
|
||||
"block override '%s' has no match in parent template '%s'",
|
||||
child.key,
|
||||
parent_path,
|
||||
)
|
||||
path := current.path
|
||||
if path == "" {
|
||||
path = "<input>"
|
||||
}
|
||||
diag := format_error(
|
||||
path,
|
||||
current.source,
|
||||
child.pos,
|
||||
msg,
|
||||
hint,
|
||||
colorize = should_colorize(),
|
||||
)
|
||||
log.warnf("%s", diag)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -18,7 +18,12 @@ leak_parse_free_tokens :: proc(t: ^testing.T) {
|
||||
mem.dynamic_arena_init(&arena)
|
||||
defer mem.dynamic_arena_destroy(&arena)
|
||||
|
||||
tmpl, err := parse("Hello {{name}}!", context.allocator, mem.dynamic_arena_allocator(&arena))
|
||||
tmpl, err := parse(
|
||||
"Hello {{name}}!",
|
||||
"<test>",
|
||||
context.allocator,
|
||||
mem.dynamic_arena_allocator(&arena),
|
||||
)
|
||||
testing.expect(t, err == nil)
|
||||
defer delete_template(&tmpl)
|
||||
}
|
||||
|
||||
+33
-17
@@ -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]
|
||||
|
||||
+13
-12
@@ -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}}]", "<test>", 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}}]", "<test>", 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}}", "<test>", 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}}", "<test>", 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}}", "<test>", 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}}]", "<test>", 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}}]", "<test>", 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}}", "<test>", 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}}", "<test>", 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}}<time datetime=\"{{.}}\">{{. | format}}</time>{{/date}}",
|
||||
context.temp_allocator,
|
||||
"<test>",
|
||||
allocator = context.temp_allocator,
|
||||
)
|
||||
result, _ := render(tpl, data, {}, context.temp_allocator)
|
||||
testing.expect_value(t, result, "<time datetime=\"2025-12-25T00:00:00Z\">25 Dec 2025</time>")
|
||||
@@ -342,7 +343,7 @@ test_format_inside_section_skips_when_empty :: proc(t: ^testing.T) {
|
||||
data := Format_Data {
|
||||
date = "",
|
||||
}
|
||||
tpl, _ := parse("[{{#date}}<time>{{. | format}}</time>{{/date}}]", context.temp_allocator)
|
||||
tpl, _ := parse("[{{#date}}<time>{{. | format}}</time>{{/date}}]", "<test>", 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}}", "<test>", allocator = context.temp_allocator)
|
||||
result, _ := render(tpl, data, {}, context.temp_allocator)
|
||||
testing.expect_value(t, result, c.expected)
|
||||
}
|
||||
|
||||
@@ -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, "<spec>", 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, "<spec>", context.temp_allocator)
|
||||
if terr != nil {
|
||||
testing.expectf(t, false, "[%s] template parse error", name)
|
||||
return false
|
||||
|
||||
@@ -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[:]
|
||||
}
|
||||
@@ -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, "<test>", 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)
|
||||
}
|
||||
|
||||
+65
-14
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user