mirror of
https://github.com/sbrow/thor.git
synced 2026-08-26 11:23:32 -04:00
wip: Approved diagnostic changes.
This commit is contained in:
Spencer Brower
@@ -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
|
||||
|
||||
+235
-44
@@ -1,28 +1,26 @@
|
||||
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 +48,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 +66,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 +95,7 @@ delete_partials :: proc(partials: map[string]Template) {
|
||||
|
||||
parse :: proc(
|
||||
source: string,
|
||||
path := "",
|
||||
allocator := context.allocator,
|
||||
tokens_allocator := context.temp_allocator,
|
||||
) -> (
|
||||
@@ -111,6 +113,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 +136,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 +161,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 +172,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 +198,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 +216,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 +237,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 +257,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 +269,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 +287,7 @@ parse_section :: proc(
|
||||
is_dynamic = tok.is_dynamic,
|
||||
indent = tok.indent,
|
||||
first_child = -1,
|
||||
pos = tok.pos,
|
||||
},
|
||||
)
|
||||
pos^ += 1
|
||||
@@ -292,9 +297,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 +314,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 +496,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 +517,7 @@ render_template :: proc(
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
render_nodes :: proc(
|
||||
current: Template,
|
||||
all_nodes: []Node,
|
||||
nodes: []Node,
|
||||
ctx: ^[dynamic]any,
|
||||
@@ -505,19 +535,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 +573,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 +611,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 +647,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 +679,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 +690,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 +701,7 @@ render_nodes :: proc(
|
||||
content_nodes: []Node
|
||||
content_pool: []Node
|
||||
content_blocks := blocks
|
||||
render_current := current
|
||||
|
||||
found_override := false
|
||||
if blocks != nil {
|
||||
@@ -638,6 +709,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 +721,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 +732,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 +745,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 +763,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 +780,7 @@ merge_block_overrides :: proc(
|
||||
all_nodes = all_nodes,
|
||||
first = child.first_child,
|
||||
count = child.child_count,
|
||||
source = source,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -711,3 +790,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