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
|
||||
|
||||
|
||||
@@ -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),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -13,6 +13,7 @@ Syntax_Error :: struct {
|
||||
msg: string,
|
||||
pos: int,
|
||||
}
|
||||
|
||||
Data_Error :: struct {
|
||||
msg: string,
|
||||
pos: int,
|
||||
|
||||
Reference in New Issue
Block a user