1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
|
module T = Colitur_render.Template
let parse_ok s = match T.parse s with Ok ns -> ns | Error e -> Alcotest.failf "parse: %s" e
let test_plain_text () =
Alcotest.(check bool) "text only" true (parse_ok "hello" = [ T.Text "hello" ])
let test_var () =
Alcotest.(check bool) "var" true (parse_ok "{{name}}" = [ T.Var [ "name" ] ]);
Alcotest.(check bool) "dotted" true (parse_ok "{{name.la}}" = [ T.Var [ "name"; "la" ] ]);
Alcotest.(check bool) "spaces trimmed" true (parse_ok "{{ name.la }}" = [ T.Var [ "name"; "la" ] ])
let test_section () =
Alcotest.(check bool) "section" true
(parse_ok "{{#days}}x{{/days}}" = [ T.Section ([ "days" ], [ T.Text "x" ]) ]);
Alcotest.(check bool) "inverted" true
(parse_ok "{{^days}}x{{/days}}" = [ T.Inverted ([ "days" ], [ T.Text "x" ]) ])
let test_nested_sections () =
Alcotest.(check bool) "nested" true
(parse_ok "{{#months}}{{#weeks}}w{{/weeks}}{{/months}}"
= [ T.Section ([ "months" ], [ T.Section ([ "weeks" ], [ T.Text "w" ]) ]) ])
let test_comment_is_dropped () =
Alcotest.(check bool) "comment" true (parse_ok "a{{! note }}b" = [ T.Text "a"; T.Text "b" ])
let test_unclosed_section_is_an_error () =
match T.parse "{{#days}}x" with
| Error _ -> ()
| Ok _ -> Alcotest.fail "an unclosed section must be a parse error, not silently accepted"
let test_mismatched_close_is_an_error () =
match T.parse "{{#days}}x{{/weeks}}" with
| Error _ -> ()
| Ok _ -> Alcotest.fail "a mismatched close tag must be a parse error"
let test_unterminated_tag_is_an_error () =
match T.parse "{{name" with
| Error _ -> ()
| Ok _ -> Alcotest.fail "an unterminated tag must be a parse error"
(* The safety promise (spec section 5): a template is data, never a program.
There is no raw/triple-brace form to opt out of escaping, and no partial. *)
let test_no_raw_or_partial_form () =
(* {{{name}}} is not a triple-brace "unescaped" form -- there is no such
form in this engine, so this assertion states what parsing it ACTUALLY
produces rather than gesturing at a guarantee it cannot check: the
lexer only recognises double braces, so it reads an ordinary var whose
path is the literal string "{name", then a leftover "}" as text. The
real guarantee against a raw form is structural, not this assertion:
[node] has exactly four constructors -- Text, Var, Section, Inverted --
and none of them is raw/unescaped. If [node] ever grows a fifth, raw
constructor, this test is not what will catch it. *)
Alcotest.(check bool) "triple brace parses as var + stray text" true
(parse_ok "{{{name}}}" = [ T.Var [ "{name" ]; T.Text "}" ]);
match T.parse "{{>partial}}" with
| Error _ -> ()
| Ok _ -> Alcotest.fail "partials must not parse: a template may not pull in another file"
(* No "current context" concept exists in this engine (sections push an
object; lookup falls back outward), so a bare-dot or empty-sigil path has
no meaning. Reject at parse time rather than inventing behaviour Task 3's
renderer would otherwise have to define for a case nobody designed. *)
let test_empty_path_is_an_error () =
let expect_error label s =
match T.parse s with
| Error _ -> ()
| Ok _ -> Alcotest.failf "%s: an empty tag path must be a parse error" label
in
expect_error "{{.}}" "{{.}}";
expect_error "{{ . }}" "{{ . }}";
expect_error "{{#}}{{/}}" "{{#}}{{/}}";
expect_error "{{^}}{{/}}" "{{^}}{{/}}"
let suite =
( "Template/parse",
[ Alcotest.test_case "plain text" `Quick test_plain_text;
Alcotest.test_case "vars" `Quick test_var;
Alcotest.test_case "sections" `Quick test_section;
Alcotest.test_case "nested sections" `Quick test_nested_sections;
Alcotest.test_case "comments dropped" `Quick test_comment_is_dropped;
Alcotest.test_case "unclosed section errors" `Quick test_unclosed_section_is_an_error;
Alcotest.test_case "mismatched close errors" `Quick test_mismatched_close_is_an_error;
Alcotest.test_case "unterminated tag errors" `Quick test_unterminated_tag_is_an_error;
Alcotest.test_case "no raw or partial form" `Quick test_no_raw_or_partial_form;
Alcotest.test_case "empty path errors" `Quick test_empty_path_is_an_error ] )
|
