AtlatestRepositorysigil-doc

sigil-doc / tree / testtest-reader.sgl

1(import (sigil test) (sigil fs) (sigil language) (sigil doc) (sigil doc author)
2 (sigil doc private author-runtime) (sigil doc private parser)
3 (sigil doc inspect))
4
5(define source "#lang sigil/doc\n@article[\"Minimal\" authors: '(\"Author\")]{@section[\"One\" id: \"one\"]{@p{Hello\nworld @em{nicely}.}}}")
6(define parsed (parse-document-source source "memory.sgd" 16))
7(define value (eval parsed))
8
9(define (eval-document-source source name header-end)
10 (let loop ((forms (parse-document-forms source name header-end)) (last #f))
11 (if (null? forms) last (loop (cdr forms) (eval (car forms))))))
13(test "prose reader lowers the closed D1 vocabulary"
14 (assert-true (document? value))
15 (assert-equal "Minimal" (document-title value))
16 (assert-equal "Hello world " (text-content (car (paragraph-children (car (section-children (car (document-children value))))))))
17 (assert-true (emphasis? (cadr (paragraph-children (car (section-children (car (document-children value)))))))))
19(test "locations use UTF-8 bytes and scalar columns"
20 (let* ((utf8 "#lang sigil/doc\n@article[\"UTF-8\" \"Author\"]{@p{καλημέρα @em{κόσμε}}}")
21 (doc (eval (parse-document-source utf8 "utf8.sgd" 16)))
22 (paragraph (car (document-children doc)))
23 (text-node (car (paragraph-children paragraph))))
24 (assert-true (> (srcloc-span (text-location text-node)) (string-length (text-content text-node))))))
26(test "standard reader owns argument and expression boundaries"
27 (let ((with-delimiters "#lang sigil/doc\n@article[\"a ] title\" \"Author\"]{@p{ok}}"))
28 (assert-equal "a ] title" (document-title (eval (parse-document-source with-delimiters "args.sgd" 16)))))
29 (let ((comment-delimiter "#lang sigil/doc\n@article[\"title\" ; ] belongs to the comment\n \"Author\"]{@p{ok}}"))
30 (assert-equal "title" (document-title (eval (parse-document-source comment-delimiter "comment.sgd" 16)))))
31 (assert-equal "ab"
32 (document-title (eval (parse-document-source
33 "#lang sigil/doc\n@article[(string-append \"a\" \"b\") \"A\"]{@p{body}}" "enabled.sgd" 16))))
34 (let ((message
35 (guard (exn (else (exception-message exn)))
36 (parse-document-source "#lang sigil/doc\n@(string-append \")\" \"x\"" "broken.sgd" 16))))
37 (assert-equal "read-syntax: broken.sgd:"
38 (substring message 0 (string-length "read-syntax: broken.sgd:")))))
40(test "malformed nesting is rejected"
41 (assert-error (parse-document-source "#lang sigil/doc\n@article[\"x\" \"A\"]{@p{oops}" "eof.sgd" 16))
42 (assert-error (parse-document-source "#lang sigil/doc\n}" "brace.sgd" 16)))
44(test "named blocks are generic, nested, and mix with braces"
45 (let* ((named "#lang sigil/doc\n@article[\"Named\" authors: '(\"Author\")]\n @section[\"Outer\" id: \"outer\"]\n @p{brace inside named}\n @p\n named paragraph\n @end p\n @end section\n@end article\n")
46 (doc (eval (parse-document-source named "named.sgd" 16)))
47 (section-node (car (document-children doc))))
48 (assert-equal "Named" (document-title doc))
49 (assert-equal 3 (srcloc-line (section-location section-node)))
50 (assert-equal 2 (length (section-children section-node))))
51 (let* ((generic "#lang sigil/doc\n@article[\"Generic\" \"Author\"]\n@tip\n@p{works}\n@end tip\n@end article\n")
52 (form (parse-document-source generic "generic.sgd" 16)))
53 (assert-true (pair? (syntax->datum form)))))
55(test "named terminators match exactly and inline commands require braces"
56 (assert-equal
57 "mismatch.sgd:4:1: sigil/doc: mismatched named block terminator; expected '@end section', got '@end article'"
58 (guard (exn (else (exception-message exn)))
59 (parse-document-source "#lang sigil/doc\n@article[\"x\" authors: '(\"A\")]\n@section[\"s\" id: \"s\"]\n@end article\n" "mismatch.sgd" 16)))
60 (assert-equal
61 "inline-named.sgd:2:27: sigil/doc: command requires '{...}', a line body, or a line-level named body"
62 (guard (exn (else (exception-message exn)))
63 (parse-document-source "#lang sigil/doc\n@article[\"x\" \"A\"]{text @em\nbody\n@end em\n}" "inline-named.sgd" 16))))
65(test "horizontal command spacing preserves compact semantics"
66 (define (title source) (document-title (eval (parse-document-source source "spacing.sgd" 16))))
67 (assert-equal "Compact" (title "#lang sigil/doc\n@article[\"Compact\" \"A\"]{@p{x}}"))
68 (assert-equal "Compact" (title "#lang sigil/doc\n@article \t [\"Compact\" \"A\"] \t {@p{x}}"))
69 (assert-equal "Compact" (title "#lang sigil/doc\n@article[\n \"Compact\" ; standard reader owns this comment\n \"A\"\n] {@p{x}}"))
70 ;; A newline after the argument group chooses a named body, never a later brace.
71 (let ((doc (eval (parse-document-source
72 "#lang sigil/doc\n@article[\"x\" \"A\"]\n{not an opening brace}\n@end article\n"
73 "newline.sgd" 16))))
74 (assert-equal "{not an opening brace}" (text-content (car (paragraph-children (car (document-children doc))))))))
76(test "line bodies share command semantics and stop at the physical newline"
77 (let* ((source "#lang sigil/doc\n@article[\"Lines\" authors: '(\"A\")]\n@section[\"A:B\" id: \"a-b\"]: @p{nested @em{inline}}\n@p: καλημέρα\n@anchor[\"empty\"]: \n@end article\n")
78 (doc (eval (parse-document-source source "lines.sgd" 16)))
79 (children (document-children doc))
80 (section-node (car children))
81 (following (cadr children)))
82 (assert-true (emphasis? (cadr (paragraph-children (car (section-children section-node))))))
83 (assert-equal "καλημέρα" (text-content (car (paragraph-children following))))
84 (assert-equal 4 (srcloc-line (paragraph-location following)))
85 (assert-equal 5 (srcloc-column (text-location (car (paragraph-children following)))))
86 (assert-true (anchor? (caddr children))))
87 (assert-error
88 (parse-document-source "#lang sigil/doc\n@article[\"x\" \"A\"]{@p{inline @em: rejected}}" "inline-line.sgd" 16)))
90(test "author results are nodes or proper node lists only"
91 (assert-equal "sigil/doc author: @expression must produce a document node or proper list of nodes"
92 (guard (exn (else (exception-message exn)))
93 (author-normalize "not implicitly coerced" (document-location value) 'expression)))
94 (assert-equal (list value)
95 (author-normalize (list value) (document-location value) 'expression)))
97(test "blank lines form deterministic paragraphs"
98 (let* ((prose "#lang sigil/doc\n@article[\"x\" \"A\"]{first\nline\n\nsecond}")
99 (doc (eval (parse-document-source prose "paragraphs.sgd" 16))))
100 (assert-equal 2 (length (document-children doc)))
101 (assert-equal "first line" (text-content (car (paragraph-children (car (document-children doc))))))
102 (assert-equal "second" (text-content (car (paragraph-children (cadr (document-children doc))))))))
104(test "byte header offsets map through BOM and shebang to scalar cursors"
105 (define (parse-inspected source name)
106 (let ((header (inspect-language-source source name)))
107 (eval (parse-document-source source name (language-header-end header)))))
108 (let* ((bom (string #\xFEFF))
109 (plain (string-append bom "#lang sigil/doc\n@article[\"BOM\" \"Author\"]{@p{καλημέρα}}"))
110 (script (string-append bom "#!/usr/bin/env sigil\n#lang sigil/doc\n@article[\"Script\" \"Author\"]{@p{καλημέρα}}"))
111 (plain-doc (parse-inspected plain "bom.sgd"))
112 (script-doc (parse-inspected script "script.sgd")))
113 (assert-equal "BOM" (document-title plain-doc))
114 (assert-equal 2 (srcloc-line (document-location plain-doc)))
115 (assert-equal 1 (srcloc-column (document-location plain-doc)))
116 (assert-equal "Script" (document-title script-doc))
117 (assert-equal 3 (srcloc-line (document-location script-doc)))
118 (assert-equal 1 (srcloc-column (document-location script-doc)))))
120(test "generated constructor failures retain command origins"
121 (define bad-anchor "#lang sigil/doc\n@article[\"x\" \"A\"]{\n\n@anchor[\"Bad_ID\"]{}\n}")
122 (let* ((exn (guard (exn (else exn))
123 (eval (parse-document-source bad-anchor "bad-anchor.sgd" 16))))
124 (trace (exception-stack-trace exn))
125 (frame (let loop ((i 0))
126 (if (= i (stack-trace-length trace)) #f
127 (let ((candidate (stack-trace-ref trace i)))
128 (if (and (vector? candidate) (eq? (vector-ref candidate 0) 'author-at))
129 candidate (loop (+ i 1)))))))
130 (generated (vector-ref frame 1))
131 (origin (srcloc-authoritative generated)))
132 (assert-equal "make-anchor: invalid id" (exception-message exn))
133 (assert-equal "<sigil/doc-generated>" (srcloc-file generated))
134 (assert-equal "bad-anchor.sgd" (srcloc-file origin))
135 (assert-equal 4 (srcloc-line origin))
136 (assert-equal 1 (srcloc-column origin)))
137 (assert-equal "make-section: invalid id"
138 (guard (exn (else (exception-message exn)))
139 (eval (parse-document-source "#lang sigil/doc\n@article[\"x\" \"A\"]{\n\n@section[\"Title\"]{}\n}" "bad-id.sgd" 16))))
140 (assert-equal "make-anchor: invalid id"
141 (guard (exn (else (exception-message exn)))
142 (eval (parse-document-source "#lang sigil/doc\n@article[\"x\" \"A\"]{\n\n@anchor[42]{}\n}" "bad-type.sgd" 16)))))
144(test "ordinary author bindings work through commands and expressions"
145 (let* ((authoring
146 (string-append
147 "#lang sigil/doc\n"
148 "@(define author-call-count 0)\n"
149 "@(define (authored body)\n"
150 " (set! author-call-count (+ author-call-count 1))\n"
151 " body)\n"
152 "@(define-syntax bold (syntax-rules () ((_ child) (em child))))\n"
153 "@article[\"Authoring\" \"A\"]{\n"
154 "@authored{@p{command path}}\n"
155 "@(authored (p (text \"expression path\")))\n"
156 "@p{local @bold{macro}}\n"
157 "}\n"))
158 (doc (eval-document-source authoring "authoring.sgd" 16))
159 (children (document-children doc)))
160 (assert-equal 2 (eval 'author-call-count))
161 (assert-equal "command path"
162 (text-content (car (paragraph-children (car children)))))
163 (assert-equal "expression path"
164 (text-content (car (paragraph-children (cadr children)))))
165 (assert-true
166 (emphasis? (cadr (paragraph-children (caddr children)))))))
168(test "argument groups preserve ordinary Sigil expressions and keyword calls"
169 (let* ((computed
170 (string-append
171 "#lang sigil/doc\n"
172 "@(define-syntax title-parts\n"
173 " (syntax-rules () ((_ left right) (string-append left right))))\n"
174 "@(define (computed-heading title option suffix . body)\n"
175 " (section\n"
176 " (string-append title (if (eq? option suffix:) suffix \"bad\"))\n"
177 " id: \"computed-heading\" body))\n"
178 "@article [\"Arguments\" \"A\"]\n"
179 "@computed-heading [\n"
180 " (title-parts \"Com\" \"puted\")\n"
181 " suffix: (string #\\!)\n"
182 "] {\n"
183 " @p { padded body }\n"
184 "}\n"
185 "@end article\n"))
186 (doc (eval-document-source computed "computed.sgd" 16))
187 (section-node (car (document-children doc)))
188 (paragraph (car (section-children section-node))))
189 (assert-equal "Computed!" (text-content (car (section-title section-node))))
190 (assert-equal "padded body" (text-content (car (paragraph-children paragraph))))))
192(test "author result lists flatten only at document structure boundaries"
193 (let* ((nested
194 (string-append
195 "#lang sigil/doc\n"
196 "@(define (nested body) (list (list body)))\n"
197 "@article[\"Nested\" \"A\"]{\n"
198 "@nested{@p{one}}\n"
199 "@(list (list (p (text \"two\"))))\n"
200 "}\n"))
201 (doc (eval-document-source nested "nested.sgd" 16))
202 (children (document-children doc)))
203 (assert-equal 2 (length children))
204 (assert-equal "one" (text-content (car (paragraph-children (car children)))))
205 (assert-equal "two" (text-content (car (paragraph-children (cadr children)))))))
207(test "subject code remains inert during document authoring"
208 (let* ((subject
209 (string-append
210 "#lang sigil/doc\n"
211 "@(define subject-ran #f)\n"
212 "@article[\"Subject\" \"A\"]{\n"
213 "@code[\"sigil\"]{@(set! subject-ran #t)}\n"
214 "}\n"))
215 (doc (eval-document-source subject "subject.sgd" 16))
216 (code-node (car (document-children doc))))
217 (assert-false (eval 'subject-ran))
218 (assert-equal "@(set! subject-ran #t)" (code-block-content code-node))))
220(test "one code command selects inline and preformatted block nodes"
221 (let* ((source
222 (string-append
223 "#lang sigil/doc\n"
224 "@article[\"Code\" \"A\"]{\n"
225 "@p{Call @code{map} here.}\n"
226 "@code[\"sigil\"] {\n(+ 1 2)\n}\n"
227 "@code[#f]: unlabelled line\n"
228 "@code\nnamed body\n@end code\n"
229 "}\n"))
230 (doc (eval (parse-document-source source "code.sgd" 16)))
231 (children (document-children doc))
232 (inline (cadr (paragraph-children (car children))))
233 (labelled (cadr children))
234 (line-block (caddr children))
235 (named-block (car (cdddr children))))
236 (assert-true (code? inline))
237 (assert-equal "map" (code-content inline))
238 (assert-true (code-block? labelled))
239 (assert-equal "sigil" (code-block-language labelled))
240 (assert-equal "(+ 1 2)" (code-block-content labelled))
241 (assert-false (code-block-language line-block))
242 (assert-equal "unlabelled line" (code-block-content line-block))
243 (assert-false (code-block-language named-block))
244 (assert-equal "named body" (code-block-content named-block))))
246(test "block code acquisition is raw for brace, named, and line bodies"
247 (let* ((source
248 (string-append
249 "#lang sigil/doc\n"
250 "@article[\"Raw Code\" \"A\"]\n"
251 "@code[\"brace\"] {\n email@example.com @@ @{x} {nested} καλημέρα \n}\n"
252 "@code[#f]\n email@example.com\n @@ and @end other and } are inert\n@end code\n"
253 "@code[\"line\"]: email@example.com @@ @{x} {nested} καλημέρα \n"
254 "@p{inline @code{email@@example.com} remains document markup}\n"
255 "@end article\n"))
256 (doc (eval (parse-document-source source "raw-code.sgd" 16)))
257 (children (document-children doc))
258 (brace (car children))
259 (named (cadr children))
260 (line (caddr children))
261 (inline (cadr (paragraph-children (car (cdddr children))))))
262 (assert-equal "email@example.com @@ @{x} {nested} καλημέρα"
263 (code-block-content brace))
264 (assert-equal "email@example.com\n @@ and @end other and } are inert"
265 (code-block-content named))
266 (assert-equal "email@example.com @@ @{x} {nested} καλημέρα"
267 (code-block-content line))
268 (assert-equal "email@example.com" (code-content inline))
269 (assert-equal 3 (srcloc-line (code-block-location brace)))
270 (assert-equal 1 (srcloc-column (code-block-location brace)))))
272(test "location indexing performs one deterministic scalar pass"
273 (define (pressure count)
274 (let loop ((i 0) (out "#lang sigil/doc\n@article[\"Scale\" \"A\"]{\n"))
275 (if (= i count)
276 (string-append out "}\n")
277 (loop (+ i 1)
278 (string-append out "@p{unique-" (number->string i) " καλημέρα}\n")))))
279 ;; SD-P4: the index-pass step count moved off a module-level telemetry global
280 ;; and onto the per-parse result, because that global was itself the
281 ;; non-reentrant parser state this phase removes (review finding I3). The
282 ;; asserted property is unchanged: one deterministic scalar pass whose length
283 ;; is the manuscript's, growing sub-5x. Both entry points build the index
284 ;; through the same `make-parser-state`, so the full parse is still exercised
285 ;; here and the step count is read from an inspect parse of the same source.
286 (let* ((small (pressure 20))
287 (_small-form (parse-document-source small "scale-small.sgd" 16))
288 (small-work (document-tree-index-steps
289 (inspect-document-source small "scale-small.sgd" 16)))
290 (large (pressure 80))
291 (_large-form (parse-document-source large "scale-large.sgd" 16))
292 (large-work (document-tree-index-steps
293 (inspect-document-source large "scale-large.sgd" 16))))
294 (assert-equal (string-length small) small-work)
295 (assert-equal (string-length large) large-work)
296 (assert-true (< large-work (* 5 small-work)))))
298(test "undefined commands and author exceptions retain command origins"
299 (define (author-frame exn)
300 (let ((trace (exception-stack-trace exn)))
301 (let loop ((i 0))
302 (if (= i (stack-trace-length trace)) #f
303 (let ((frame (stack-trace-ref trace i)))
304 (if (and (vector? frame) (eq? (vector-ref frame 0) 'author-at))
305 frame
306 (loop (+ i 1))))))))
307 (let* ((undefined
308 (guard (exn (else exn))
309 (eval-document-source
310 "#lang sigil/doc\n@article[\"x\" \"A\"]{\n@does-not-exist{}\n}"
311 "undefined.sgd" 16)))
312 (undefined-origin
313 (srcloc-authoritative (vector-ref (author-frame undefined) 1))))
314 (assert-equal "unbound variable 'does-not-exist'" (exception-message undefined))
315 (assert-equal "undefined.sgd" (srcloc-file undefined-origin))
316 (assert-equal 3 (srcloc-line undefined-origin))
317 (assert-equal 1 (srcloc-column undefined-origin)))
318 (let* ((exploded
319 (guard (exn (else exn))
320 (eval-document-source
321 (string-append
322 "#lang sigil/doc\n"
323 "@(define (explode . body) (error \"author boom\"))\n"
324 "@article[\"x\" \"A\"]{\n"
325 "@explode{}\n"
326 "}\n")
327 "explode.sgd" 16)))
328 (exploded-origin
329 (srcloc-authoritative (vector-ref (author-frame exploded) 1))))
330 (assert-equal "author boom" (exception-message exploded))
331 (assert-equal "explode.sgd" (srcloc-file exploded-origin))
332 (assert-equal 4 (srcloc-line exploded-origin))
333 (assert-equal 1 (srcloc-column exploded-origin))))