AtlatestRepositorysigil-doc
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))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))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-source33
"#lang sigil/doc\n@article[(string-append \"a\" \"b\") \"A\"]{@p{body}}" "enabled.sgd" 16))))34
(let ((message35
(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-equal57
"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-equal61
"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-source72
"#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-error88
(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)) #f127
(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* ((authoring146
(string-append147
"#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-true166
(emphasis? (cadr (paragraph-children (caddr children)))))))168
(test "argument groups preserve ordinary Sigil expressions and keyword calls"169
(let* ((computed170
(string-append171
"#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* ((nested194
(string-append195
"#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* ((subject209
(string-append210
"#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* ((source222
(string-append223
"#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* ((source248
(string-append249
"#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 global280
;; and onto the per-parse result, because that global was itself the281
;; non-reentrant parser state this phase removes (review finding I3). The282
;; asserted property is unchanged: one deterministic scalar pass whose length283
;; is the manuscript's, growing sub-5x. Both entry points build the index284
;; through the same `make-parser-state`, so the full parse is still exercised285
;; 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-steps289
(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-steps293
(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)) #f303
(let ((frame (stack-trace-ref trace i)))304
(if (and (vector? frame) (eq? (vector-ref frame 0) 'author-at))305
frame306
(loop (+ i 1))))))))307
(let* ((undefined308
(guard (exn (else exn))309
(eval-document-source310
"#lang sigil/doc\n@article[\"x\" \"A\"]{\n@does-not-exist{}\n}"311
"undefined.sgd" 16)))312
(undefined-origin313
(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* ((exploded319
(guard (exn (else exn))320
(eval-document-source321
(string-append322
"#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-origin329
(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))))