BlueGit

timfa posprint

Files

posprint / src / dsl / parser.rs

parser.rs

parser.rs 35.6 KiB Download Raw
1use super::{
2 Align, BarcodeMode, BarcodeSymbology, Block, Document, ImageWidth, Inline, ListItem, ParseError,
3 QrEcc, QrMode,
4};
5
6pub fn parse(source: &str) -> Result<Document, ParseError> {
7 let source = strip_comments(source);
8 let mut blocks = Vec::new();
9 let mut lines = source.lines().peekable();
10 let mut line_no = 0usize;
11 let mut current_align = Align::Left;
12
13 while let Some(raw_line) = lines.next() {
14 line_no += 1;
15 let line = raw_line.trim_end();
16
17 let (content, align_for_block) = match parse_align_line(line) {
18 Some((align, None)) => {
19 current_align = align;
20 continue;
21 }
22 Some((align, Some(rest))) => {
23 current_align = align;
24 (rest, current_align)
25 }
26 None => (line, current_align),
27 };
28
29 if is_blank_feed_line(content) {
30 blocks.push(Block::Feed(1));
31 continue;
32 }
33
34 let segments = split_aligned_segments(content, align_for_block);
35 if segments.is_empty() {
36 continue;
37 }
38
39 for (idx, (seg_align, seg_text)) in segments.iter().enumerate() {
40 current_align = *seg_align;
41 let allow_multiline_paragraph = segments.len() == 1 && idx == segments.len() - 1;
42
43 if is_blank_feed_line(seg_text) {
44 blocks.push(Block::Feed(1));
45 continue;
46 }
47
48 if seg_text.starts_with('#') {
49 blocks.push(parse_heading(seg_text, line_no, *seg_align)?);
50 continue;
51 }
52
53 if seg_text.trim() == "---" {
54 blocks.push(Block::Rule);
55 continue;
56 }
57
58 if seg_text.trim_start().starts_with("@") {
59 blocks.push(parse_directive(seg_text.trim(), line_no, *seg_align)?);
60 continue;
61 }
62
63 if is_list_item_line(seg_text) {
64 let mut items = vec![parse_list_item(seg_text, line_no)?];
65 while let Some(&next) = lines.peek() {
66 if is_blank_feed_line(next)
67 || next.starts_with('#')
68 || next.trim() == "---"
69 || next.trim_start().starts_with('@')
70 || parse_align_line(next).is_some()
71 || !is_list_item_line(next.trim_end())
72 {
73 break;
74 }
75 line_no += 1;
76 let next_line = lines.next().unwrap().trim_end();
77 items.push(parse_list_item(next_line, line_no)?);
78 }
79 blocks.push(Block::List {
80 align: *seg_align,
81 items,
82 });
83 continue;
84 }
85
86 if allow_multiline_paragraph {
87 let mut paragraph_lines = vec![seg_text.clone()];
88 while let Some(&next) = lines.peek() {
89 if is_blank_feed_line(next)
90 || next.starts_with('#')
91 || next.trim() == "---"
92 || next.trim_start().starts_with('@')
93 || parse_align_line(next).is_some()
94 || is_list_item_line(next.trim_end())
95 {
96 break;
97 }
98 line_no += 1;
99 lines.next();
100 paragraph_lines.push(next.trim_end().to_string());
101 }
102 let text = paragraph_lines.join("\n");
103 blocks.push(Block::Paragraph {
104 align: *seg_align,
105 inlines: parse_inlines(&text, line_no, 1)?,
106 });
107 } else {
108 blocks.push(Block::Paragraph {
109 align: *seg_align,
110 inlines: parse_inlines(seg_text, line_no, 1)?,
111 });
112 }
113 }
114 }
115
116 let document = Document { blocks };
117 validate_param_kinds(&document)?;
118 Ok(document)
119}
120
121fn validate_param_kinds(document: &Document) -> Result<(), ParseError> {
122 use std::collections::BTreeSet;
123
124 let mut text_names = BTreeSet::new();
125 let mut bool_names = BTreeSet::new();
126 for block in &document.blocks {
127 collect_param_kinds_from_block(block, &mut text_names, &mut bool_names);
128 }
129 for name in text_names.intersection(&bool_names) {
130 return Err(err(
131 1,
132 1,
133 format!(
134 "parameter '{name}' cannot be both ${{{name}}} (text) and $[{name}] (checkbox)"
135 ),
136 ));
137 }
138 Ok(())
139}
140
141fn collect_param_kinds_from_block(
142 block: &Block,
143 text_names: &mut std::collections::BTreeSet<String>,
144 bool_names: &mut std::collections::BTreeSet<String>,
145) {
146 match block {
147 Block::Paragraph { inlines, .. } | Block::Heading { inlines, .. } => {
148 for inline in inlines {
149 match inline {
150 Inline::Param(name) => {
151 text_names.insert(name.clone());
152 }
153 Inline::CheckboxParam(name) => {
154 bool_names.insert(name.clone());
155 }
156 _ => {}
157 }
158 }
159 }
160 Block::List { items, .. } => {
161 for item in items {
162 for inline in &item.inlines {
163 match inline {
164 Inline::Param(name) => {
165 text_names.insert(name.clone());
166 }
167 Inline::CheckboxParam(name) => {
168 bool_names.insert(name.clone());
169 }
170 _ => {}
171 }
172 }
173 }
174 }
175 Block::Image { path, .. } => collect_text_params_from_raw(path, text_names),
176 Block::Barcode { data, .. } | Block::Qr { data, .. } => {
177 collect_text_params_from_raw(data, text_names);
178 }
179 Block::Rule | Block::Feed(_) | Block::Cut | Block::Date { .. } | Block::Time { .. } => {}
180 }
181}
182
183fn collect_text_params_from_raw(text: &str, text_names: &mut std::collections::BTreeSet<String>) {
184 let chars: Vec<char> = text.chars().collect();
185 let mut i = 0;
186 while i < chars.len() {
187 if chars[i] == '$' && i + 1 < chars.len() && chars[i + 1] == '{' {
188 let start = i + 2;
189 let mut j = start;
190 while j < chars.len() && chars[j] != '}' {
191 j += 1;
192 }
193 if j < chars.len() {
194 text_names.insert(chars[start..j].iter().collect());
195 i = j + 1;
196 continue;
197 }
198 }
199 i += 1;
200 }
201}
202
203/// True when the last substantive block is `@cut` (trailing blank-line feeds are ignored).
204pub fn document_ends_with_cut(document: &Document) -> bool {
205 for block in document.blocks.iter().rev() {
206 match block {
207 Block::Feed(_) => continue,
208 Block::Cut => return true,
209 _ => return false,
210 }
211 }
212 false
213}
214
215fn strip_comments(source: &str) -> String {
216 let mut out = String::with_capacity(source.len());
217 let mut chars = source.chars().peekable();
218 while let Some(ch) = chars.next() {
219 if ch == '<' && chars.peek() == Some(&'!') {
220 let mut rest: String = chars.clone().collect();
221 if rest.starts_with('!') {
222 let _ = chars.next();
223 rest = chars.clone().collect();
224 if rest.starts_with("--") {
225 for _ in 0..3 {
226 chars.next();
227 }
228 while let Some(c) = chars.next() {
229 if c == '-' && chars.peek() == Some(&'-') {
230 chars.next();
231 if chars.peek() == Some(&'>') {
232 chars.next();
233 break;
234 }
235 }
236 }
237 continue;
238 }
239 }
240 out.push('<');
241 } else {
242 out.push(ch);
243 }
244 }
245 out
246}
247
248/// Parse `:left:`, `:center:`, `:centre:`, or `:right:` at line start.
249/// Returns the alignment and optional remaining content on the same line.
250fn parse_align_line(line: &str) -> Option<(Align, Option<&str>)> {
251 let trimmed = line.trim_start();
252 if let Some(rest) = trimmed.strip_prefix(":left:") {
253 let rest = rest.trim_start();
254 return Some((
255 Align::Left,
256 if rest.is_empty() { None } else { Some(rest) },
257 ));
258 }
259 if let Some(rest) = trimmed.strip_prefix(":center:") {
260 let rest = rest.trim_start();
261 return Some((
262 Align::Center,
263 if rest.is_empty() { None } else { Some(rest) },
264 ));
265 }
266 if let Some(rest) = trimmed.strip_prefix(":centre:") {
267 let rest = rest.trim_start();
268 return Some((
269 Align::Center,
270 if rest.is_empty() { None } else { Some(rest) },
271 ));
272 }
273 if let Some(rest) = trimmed.strip_prefix(":right:") {
274 let rest = rest.trim_start();
275 return Some((
276 Align::Right,
277 if rest.is_empty() { None } else { Some(rest) },
278 ));
279 }
280 None
281}
282
283/// Split line content on embedded `:left:`, `:center:`, `:centre:`, or `:right:` markers.
284/// Leading spaces in each segment are preserved (for manual indent); trailing spaces are trimmed.
285fn split_aligned_segments(content: &str, start_align: Align) -> Vec<(Align, String)> {
286 let mut segments = Vec::new();
287 let mut align = start_align;
288 let mut rest = content;
289
290 while let Some((pos, new_align, marker_len)) = find_next_align_marker(rest) {
291 let before = rest[..pos].trim_end();
292 if !before.trim().is_empty() {
293 segments.push((align, before.to_string()));
294 }
295 align = new_align;
296 rest = rest[pos + marker_len..].trim_start();
297 }
298
299 let tail = rest.trim_end();
300 if !tail.trim().is_empty() {
301 segments.push((align, tail.to_string()));
302 }
303 segments
304}
305
306fn find_next_align_marker(s: &str) -> Option<(usize, Align, usize)> {
307 const MARKERS: &[(&str, Align)] = &[
308 (":left:", Align::Left),
309 (":center:", Align::Center),
310 (":centre:", Align::Center),
311 (":right:", Align::Right),
312 ];
313
314 let mut best: Option<(usize, Align, usize)> = None;
315 for (pat, marker_align) in MARKERS {
316 if let Some(pos) = s.find(pat) {
317 if best.is_none() || pos < best.unwrap().0 {
318 best = Some((pos, *marker_align, pat.len()));
319 }
320 }
321 }
322 best
323}
324
325/// True only when a line has no visible content (empty or whitespace-only).
326/// Lines with DSL markers (`:right:`, `@feed`, `#`, etc.) are never feed lines.
327fn is_blank_feed_line(line: &str) -> bool {
328 line.chars().all(|c| c.is_whitespace())
329}
330
331fn parse_heading(line: &str, line_no: usize, align: Align) -> Result<Block, ParseError> {
332 let mut level = 0u8;
333 for ch in line.chars() {
334 if ch == '#' {
335 level += 1;
336 } else {
337 break;
338 }
339 }
340 if level == 0 || level > 2 {
341 return Err(err(line_no, 1, "heading must use # or ##"));
342 }
343 let text = line[level as usize..].trim();
344 if text.is_empty() {
345 return Err(err(line_no, 1, "heading text is empty"));
346 }
347 Ok(Block::Heading {
348 level,
349 align,
350 inlines: parse_inlines(text, line_no, level as usize + 1)?,
351 })
352}
353
354fn parse_directive(line: &str, line_no: usize, default_align: Align) -> Result<Block, ParseError> {
355 let body = line
356 .trim_start()
357 .strip_prefix('@')
358 .ok_or_else(|| err(line_no, 1, "expected directive"))?;
359 let mut parts = body.split_whitespace();
360 let name = parts.next().unwrap_or("").to_ascii_lowercase();
361 match name.as_str() {
362 "feed" => {
363 let n = parts
364 .next()
365 .ok_or_else(|| err(line_no, 1, "@feed requires line count"))?;
366 let lines: u8 = n
367 .parse()
368 .map_err(|_| err(line_no, 1, "@feed count must be 0-255"))?;
369 Ok(Block::Feed(lines))
370 }
371 "cut" => Ok(Block::Cut),
372 "image" => parse_image_directive(parts.collect(), line_no, default_align),
373 "barcode" => parse_barcode_directive(parts.collect(), line_no, default_align),
374 "qr" => parse_qr_directive(parts.collect(), line_no, default_align),
375 "date" => parse_date_directive(parts.collect(), line_no, default_align),
376 "time" => parse_time_directive(parts.collect(), line_no, default_align),
377 _ => Err(err(line_no, 1, format!("unknown directive @{name}"))),
378 }
379}
380
381fn parse_image_directive(
382 parts: Vec<&str>,
383 line_no: usize,
384 default_align: Align,
385) -> Result<Block, ParseError> {
386 if parts.is_empty() {
387 return Err(err(line_no, 1, "@image requires a path"));
388 }
389 let path = parts[0].to_string();
390 let mut width = ImageWidth::Default;
391 let mut align = default_align;
392 for attr in &parts[1..] {
393 if let Some((k, v)) = attr.split_once('=') {
394 match k.to_ascii_lowercase().as_str() {
395 "width" => {
396 width = if let Some(p) = v.strip_suffix('%') {
397 let pct: u8 = p
398 .parse()
399 .map_err(|_| err(line_no, 1, "invalid width percent"))?;
400 ImageWidth::Percent(pct.min(100))
401 } else {
402 let dots: u16 = v
403 .parse()
404 .map_err(|_| err(line_no, 1, "invalid width dots"))?;
405 ImageWidth::Dots(dots)
406 };
407 }
408 "align" => align = parse_align_value(v, line_no)?,
409 _ => return Err(err(line_no, 1, format!("unknown image attribute {k}"))),
410 }
411 }
412 }
413 Ok(Block::Image { path, width, align })
414}
415
416fn parse_barcode_directive(
417 parts: Vec<&str>,
418 line_no: usize,
419 default_align: Align,
420) -> Result<Block, ParseError> {
421 if parts.len() < 2 {
422 return Err(err(
423 line_no,
424 1,
425 "@barcode requires symbology and data (or RASTER symbology data)",
426 ));
427 }
428
429 let (mode, sym_idx, data_idx) = if parts[0].eq_ignore_ascii_case("RASTER") {
430 if parts.len() < 3 {
431 return Err(err(
432 line_no,
433 1,
434 "@barcode RASTER requires symbology and data",
435 ));
436 }
437 (BarcodeMode::Raster, 1, 2)
438 } else {
439 (BarcodeMode::Native, 0, 1)
440 };
441
442 let symbology = BarcodeSymbology::from_name(parts[sym_idx])
443 .ok_or_else(|| err(line_no, 1, format!("unknown barcode symbology {}", parts[sym_idx])))?;
444
445 if mode == BarcodeMode::Native && !symbology.supports_native() {
446 return Err(err(
447 line_no,
448 1,
449 format!(
450 "{} has no native ESC/POS support; use RASTER {}",
451 symbology.as_str(),
452 symbology.as_str()
453 ),
454 ));
455 }
456
457 let data = parts[data_idx].to_string();
458 let attr_start = data_idx + 1;
459 let mut height = 64u8;
460 let mut align = default_align;
461 let mut show_text = true;
462 for attr in &parts[attr_start..] {
463 if let Some((k, v)) = attr.split_once('=') {
464 match k.to_ascii_lowercase().as_str() {
465 "height" => {
466 height = v
467 .parse()
468 .map_err(|_| err(line_no, 1, "invalid barcode height"))?;
469 }
470 "align" => align = parse_align_value(v, line_no)?,
471 "show_text" => show_text = v == "true",
472 _ => return Err(err(line_no, 1, format!("unknown barcode attribute {k}"))),
473 }
474 }
475 }
476 Ok(Block::Barcode {
477 mode,
478 symbology,
479 data,
480 height,
481 align,
482 show_text,
483 })
484}
485
486fn parse_date_directive(
487 parts: Vec<&str>,
488 _line_no: usize,
489 default_align: Align,
490) -> Result<Block, ParseError> {
491 let pattern = parts.join(" ");
492 let format = if pattern.is_empty() {
493 None
494 } else {
495 Some(pattern)
496 };
497 Ok(Block::Date {
498 format,
499 align: default_align,
500 })
501}
502
503fn parse_time_directive(
504 parts: Vec<&str>,
505 line_no: usize,
506 default_align: Align,
507) -> Result<Block, ParseError> {
508 use super::TimeFormatSpec;
509 let spec = match parts.first().map(|s| s.to_ascii_lowercase()).as_deref() {
510 None => TimeFormatSpec::Hours24,
511 Some("12h") => TimeFormatSpec::Hours12,
512 Some("24h") => TimeFormatSpec::Hours24,
513 Some(other) => {
514 return Err(err(
515 line_no,
516 1,
517 format!("unknown @time format '{other}' (use 12h or 24h)"),
518 ));
519 }
520 };
521 if parts.len() > 1 {
522 return Err(err(
523 line_no,
524 1,
525 "@time accepts at most one format argument (12h or 24h)",
526 ));
527 }
528 Ok(Block::Time {
529 format: spec,
530 align: default_align,
531 })
532}
533
534fn parse_qr_directive(
535 parts: Vec<&str>,
536 line_no: usize,
537 default_align: Align,
538) -> Result<Block, ParseError> {
539 if parts.is_empty() {
540 return Err(err(line_no, 1, "@qr requires data"));
541 }
542
543 let (mode, data_idx) = if parts[0].eq_ignore_ascii_case("RASTER") {
544 if parts.len() < 2 {
545 return Err(err(line_no, 1, "@qr RASTER requires data"));
546 }
547 (QrMode::Raster, 1)
548 } else {
549 (QrMode::Native, 0)
550 };
551
552 let data = parts[data_idx].to_string();
553 let attr_start = data_idx + 1;
554 let mut size = 4u8;
555 let mut ecc = QrEcc::M;
556 let mut align = default_align;
557 let mut version = None;
558 for attr in &parts[attr_start..] {
559 if let Some((k, v)) = attr.split_once('=') {
560 match k.to_ascii_lowercase().as_str() {
561 "size" => {
562 size = v
563 .parse::<u8>()
564 .map_err(|_| err(line_no, 1, "invalid qr size"))?
565 .clamp(1, 16);
566 }
567 "scale" => {
568 size = v
569 .parse::<u8>()
570 .map_err(|_| err(line_no, 1, "invalid qr scale"))?
571 .clamp(1, 16);
572 }
573 "version" => {
574 let ver: u8 = v
575 .parse()
576 .map_err(|_| err(line_no, 1, "invalid qr version"))?;
577 if !(1..=40).contains(&ver) {
578 return Err(err(line_no, 1, "qr version must be 1-40"));
579 }
580 version = Some(ver);
581 }
582 "ecc" => {
583 ecc = QrEcc::from_name(v)
584 .ok_or_else(|| err(line_no, 1, "qr ecc must be L, M, Q, or H"))?;
585 }
586 "align" => align = parse_align_value(v, line_no)?,
587 _ => return Err(err(line_no, 1, format!("unknown qr attribute {k}"))),
588 }
589 }
590 }
591 Ok(Block::Qr {
592 mode,
593 data,
594 size,
595 ecc,
596 version,
597 align,
598 })
599}
600
601fn parse_align_value(value: &str, line_no: usize) -> Result<Align, ParseError> {
602 match value.to_ascii_lowercase().as_str() {
603 "left" => Ok(Align::Left),
604 "center" | "centre" => Ok(Align::Center),
605 "right" => Ok(Align::Right),
606 _ => Err(err(line_no, 1, "align must be left, center, or right")),
607 }
608}
609
610fn is_list_item_line(line: &str) -> bool {
611 line.trim_start().starts_with("- ")
612}
613
614/// Nesting depth from leading whitespace: two spaces (or one tab) per level.
615fn list_item_depth(line: &str) -> u8 {
616 let mut spaces = 0u32;
617 for ch in line.chars() {
618 match ch {
619 ' ' => spaces += 1,
620 '\t' => spaces += 2,
621 _ => break,
622 }
623 }
624 spaces.div_euclid(2).min(u32::from(u8::MAX)) as u8
625}
626
627fn list_item_text(line: &str) -> &str {
628 line.trim_start()
629 .strip_prefix("- ")
630 .map(str::trim_end)
631 .unwrap_or(line.trim_end())
632}
633
634fn parse_list_item(line: &str, line_no: usize) -> Result<ListItem, ParseError> {
635 Ok(ListItem {
636 depth: list_item_depth(line),
637 inlines: parse_inlines(list_item_text(line), line_no, 1)?,
638 })
639}
640
641fn parse_inlines(input: &str, line: usize, col: usize) -> Result<Vec<Inline>, ParseError> {
642 let mut out = Vec::new();
643 let mut i = 0usize;
644 let chars: Vec<char> = input.chars().collect();
645 while i < chars.len() {
646 if chars[i] == '$' && i + 1 < chars.len() {
647 match chars[i + 1] {
648 '{' => {
649 let start = i + 2;
650 let mut j = start;
651 while j < chars.len() && chars[j] != '}' {
652 j += 1;
653 }
654 if j >= chars.len() {
655 return Err(err(line, col + i, "unclosed parameter ${...}"));
656 }
657 let name: String = chars[start..j].iter().collect();
658 if !is_valid_param_name(&name) {
659 return Err(err(
660 line,
661 col + i,
662 format!("invalid parameter name '{name}'"),
663 ));
664 }
665 out.push(Inline::Param(name));
666 i = j + 1;
667 continue;
668 }
669 '[' => {
670 let start = i + 2;
671 let mut j = start;
672 while j < chars.len() && chars[j] != ']' {
673 j += 1;
674 }
675 if j >= chars.len() {
676 return Err(err(line, col + i, "unclosed parameter $[...]"));
677 }
678 let name: String = chars[start..j].iter().collect();
679 if !is_valid_param_name(&name) {
680 return Err(err(
681 line,
682 col + i,
683 format!("invalid checkbox parameter name '{name}'"),
684 ));
685 }
686 out.push(Inline::CheckboxParam(name));
687 i = j + 1;
688 continue;
689 }
690 _ => {}
691 }
692 }
693 if let Some((checked, consumed)) = try_parse_checkbox(&chars[i..]) {
694 out.push(Inline::Checkbox { checked });
695 i += consumed;
696 continue;
697 }
698 let start = i;
699 while i < chars.len() && chars[i] != '$' {
700 // Stop before a checkbox so it becomes its own inline.
701 if try_parse_checkbox(&chars[i..]).is_some() {
702 break;
703 }
704 i += 1;
705 }
706 if i == start {
707 i += 1;
708 continue;
709 }
710 out.push(Inline::Text(chars[start..i].iter().collect()));
711 }
712 Ok(out)
713}
714
715/// Parse `[]`, `[ ]`, `[x]`, or `[X]` at the start of `chars`.
716/// Returns `(checked, chars_consumed)`.
717fn try_parse_checkbox(chars: &[char]) -> Option<(bool, usize)> {
718 if chars.first() != Some(&'[') {
719 return None;
720 }
721 match chars.get(1) {
722 Some(']') => Some((false, 2)),
723 Some(' ') if chars.get(2) == Some(&']') => Some((false, 3)),
724 Some('x' | 'X') if chars.get(2) == Some(&']') => Some((true, 3)),
725 _ => None,
726 }
727}
728
729fn is_valid_param_name(name: &str) -> bool {
730 let mut chars = name.chars();
731 match chars.next() {
732 Some(c) if c.is_ascii_alphabetic() || c == '_' => {}
733 _ => return false,
734 }
735 chars.all(|c| c.is_ascii_alphanumeric() || c == '_')
736}
737
738fn err(line: usize, column: usize, message: impl Into<String>) -> ParseError {
739 ParseError {
740 line,
741 column,
742 message: message.into(),
743 }
744}
745
746#[cfg(test)]
747mod tests {
748 use super::*;
749 use crate::dsl::{BarcodeMode, BarcodeSymbology, Inline, TimeFormatSpec};
750
751 fn inlines_to_text(inlines: &[Inline]) -> String {
752 let mut out = String::new();
753 for inline in inlines {
754 match inline {
755 Inline::Text(t) | Inline::Param(t) | Inline::CheckboxParam(t) => out.push_str(t),
756 Inline::Checkbox { checked } => {
757 out.push_str(crate::dsl::checkbox_glyph(*checked));
758 }
759 }
760 }
761 out
762 }
763
764 #[test]
765 fn parses_inline_checkboxes() {
766 let doc = parse("[] empty\n[ ] spaced\n[x] done\n[X] also").unwrap();
767 assert_eq!(doc.blocks.len(), 1);
768 let Block::Paragraph { inlines, .. } = &doc.blocks[0] else {
769 panic!("expected paragraph");
770 };
771 let glyphs: Vec<_> = inlines
772 .iter()
773 .filter_map(|i| match i {
774 Inline::Checkbox { checked } => Some(*checked),
775 _ => None,
776 })
777 .collect();
778 assert_eq!(glyphs, vec![false, false, true, true]);
779 }
780
781 #[test]
782 fn parses_checkbox_param() {
783 let doc = parse("$[Paid] ok").unwrap();
784 let Block::Paragraph { inlines, .. } = &doc.blocks[0] else {
785 panic!("expected paragraph");
786 };
787 assert!(matches!(
788 &inlines[0],
789 Inline::CheckboxParam(name) if name == "Paid"
790 ));
791 }
792
793 #[test]
794 fn rejects_same_name_as_text_and_checkbox_param() {
795 let err = parse("${Paid}\n$[Paid]").unwrap_err();
796 assert!(
797 err.message.contains("cannot be both"),
798 "unexpected error: {}",
799 err.message
800 );
801 }
802
803 #[test]
804 fn parses_heading_and_paragraph() {
805 let doc = parse("# Store\nHello world").unwrap();
806 assert_eq!(doc.blocks.len(), 2);
807 assert!(matches!(doc.blocks[0], Block::Heading { level: 1, .. }));
808 assert!(matches!(doc.blocks[1], Block::Paragraph { .. }));
809 }
810
811 #[test]
812 fn preserves_leading_spaces_in_paragraph() {
813 let doc = parse(" hoi").unwrap();
814 let Block::Paragraph { inlines, .. } = &doc.blocks[0] else {
815 panic!("expected paragraph");
816 };
817 assert_eq!(inlines_to_text(inlines), " hoi");
818 }
819
820 #[test]
821 fn trims_trailing_but_keeps_leading_spaces() {
822 let doc = parse(" hello ").unwrap();
823 let Block::Paragraph { inlines, .. } = &doc.blocks[0] else {
824 panic!("expected paragraph");
825 };
826 assert_eq!(inlines_to_text(inlines), " hello");
827 }
828
829 #[test]
830 fn parses_bullet_list() {
831 let doc = parse("- this\n- is then\n- a list").unwrap();
832 assert_eq!(doc.blocks.len(), 1);
833 let Block::List { items, .. } = &doc.blocks[0] else {
834 panic!("expected list");
835 };
836 assert_eq!(items.len(), 3);
837 assert_eq!(inlines_to_text(&items[0].inlines), "this");
838 assert_eq!(inlines_to_text(&items[1].inlines), "is then");
839 assert_eq!(inlines_to_text(&items[2].inlines), "a list");
840 assert_eq!(items[0].depth, 0);
841 }
842
843 #[test]
844 fn parses_nested_bullet_list() {
845 let doc = parse("- Groceries\n - Milk\n - Eggs\n- Wash car").unwrap();
846 let Block::List { items, .. } = &doc.blocks[0] else {
847 panic!("expected list");
848 };
849 assert_eq!(items.len(), 4);
850 assert_eq!(items[0].depth, 0);
851 assert_eq!(inlines_to_text(&items[0].inlines), "Groceries");
852 assert_eq!(items[1].depth, 1);
853 assert_eq!(inlines_to_text(&items[1].inlines), "Milk");
854 assert_eq!(items[2].depth, 1);
855 assert_eq!(items[3].depth, 0);
856 assert_eq!(inlines_to_text(&items[3].inlines), "Wash car");
857 }
858
859 #[test]
860 fn blank_line_breaks_bullet_list() {
861 let doc = parse("- one\n\n- two").unwrap();
862 assert_eq!(doc.blocks.len(), 3);
863 assert!(matches!(doc.blocks[0], Block::List { .. }));
864 assert!(matches!(doc.blocks[1], Block::Feed(1)));
865 assert!(matches!(doc.blocks[2], Block::List { .. }));
866 }
867
868 #[test]
869 fn parses_parameters() {
870 let doc = parse("Order ${OrderId}").unwrap();
871 let Block::Paragraph { inlines, .. } = &doc.blocks[0] else {
872 panic!("expected paragraph");
873 };
874 assert!(matches!(
875 inlines.as_slice(),
876 [
877 Inline::Text(_),
878 Inline::Param(name)
879 ] if name == "OrderId"
880 ));
881 }
882
883 #[test]
884 fn dedupes_collect_is_separate_module() {
885 let doc = parse("@barcode CODE128 ${A}\n@qr ${A}").unwrap();
886 assert_eq!(doc.blocks.len(), 2);
887 }
888
889 #[test]
890 fn strips_comments() {
891 let doc = parse("<!-- hidden -->Visible").unwrap();
892 assert_eq!(doc.blocks.len(), 1);
893 let doc = parse("<!-- hidden -->\nVisible").unwrap();
894 assert!(matches!(doc.blocks[0], Block::Feed(1)));
895 }
896
897 #[test]
898 fn rejects_unknown_directive() {
899 assert!(parse("@unknown x").is_err());
900 }
901
902 #[test]
903 fn parses_alignment_prefix() {
904 let doc = parse(":center:\nCentered").unwrap();
905 let Block::Paragraph { align, .. } = &doc.blocks[0] else {
906 panic!();
907 };
908 assert_eq!(*align, Align::Center);
909 }
910
911 #[test]
912 fn persistent_center_applies_to_heading_and_directives() {
913 let doc = parse(
914 ":center:\n# Hello\n@qr ${Data}\n@barcode RASTER CODE128 ${Data}\n:left:\nLeft\n",
915 )
916 .unwrap();
917 assert_eq!(doc.blocks.len(), 4);
918 assert!(matches!(
919 doc.blocks[0],
920 Block::Heading {
921 align: Align::Center,
922 ..
923 }
924 ));
925 assert!(matches!(
926 doc.blocks[1],
927 Block::Qr {
928 align: Align::Center,
929 ..
930 }
931 ));
932 assert!(matches!(
933 doc.blocks[2],
934 Block::Barcode {
935 align: Align::Center,
936 ..
937 }
938 ));
939 assert!(matches!(
940 doc.blocks[3],
941 Block::Paragraph {
942 align: Align::Left,
943 ..
944 }
945 ));
946 }
947
948 #[test]
949 fn persistent_center_groups_following_paragraph_lines() {
950 let doc = parse(":center:\nLine one\nLine two").unwrap();
951 assert_eq!(doc.blocks.len(), 1);
952 let Block::Paragraph { align, inlines } = &doc.blocks[0] else {
953 panic!();
954 };
955 assert_eq!(*align, Align::Center);
956 assert_eq!(inlines_to_text(inlines), "Line one\nLine two");
957 }
958
959 #[test]
960 fn align_prefix_on_same_line_sets_persistent_state() {
961 let doc = parse(":center: Inline\nNext").unwrap();
962 assert_eq!(doc.blocks.len(), 1);
963 let Block::Paragraph { align, inlines } = &doc.blocks[0] else {
964 panic!();
965 };
966 assert_eq!(*align, Align::Center);
967 assert_eq!(inlines_to_text(inlines), "Inline\nNext");
968 }
969
970 #[test]
971 fn multiple_align_prefixes_on_one_line() {
972 let doc = parse(":left:left :right:right").unwrap();
973 assert_eq!(doc.blocks.len(), 2);
974 assert!(matches!(
975 doc.blocks[0],
976 Block::Paragraph {
977 align: Align::Left,
978 ..
979 }
980 ));
981 assert!(matches!(
982 doc.blocks[1],
983 Block::Paragraph {
984 align: Align::Right,
985 ..
986 }
987 ));
988 let Block::Paragraph { inlines: left, .. } = &doc.blocks[0] else {
989 panic!();
990 };
991 let Block::Paragraph { inlines: right, .. } = &doc.blocks[1] else {
992 panic!();
993 };
994 assert_eq!(inlines_to_text(left), "left");
995 assert_eq!(inlines_to_text(right), "right");
996 }
997
998 #[test]
999 fn align_only_line_does_not_emit_block() {
1000 let doc = parse(":center:\n:center:").unwrap();
1001 assert!(doc.blocks.is_empty());
1002 }
1003
1004 #[test]
1005 fn parses_date_and_time_directives() {
1006 let doc = parse("@date\n@date DD-YYYY-MM\n@time\n@time 12h").unwrap();
1007 assert!(matches!(
1008 doc.blocks[0],
1009 Block::Date {
1010 format: None,
1011 ..
1012 }
1013 ));
1014 assert!(matches!(
1015 doc.blocks[1],
1016 Block::Date {
1017 format: Some(ref f),
1018 ..
1019 } if f == "DD-YYYY-MM"
1020 ));
1021 assert!(matches!(
1022 doc.blocks[2],
1023 Block::Time {
1024 format: TimeFormatSpec::Hours24,
1025 ..
1026 }
1027 ));
1028 assert!(matches!(
1029 doc.blocks[3],
1030 Block::Time {
1031 format: TimeFormatSpec::Hours12,
1032 ..
1033 }
1034 ));
1035 }
1036
1037 #[test]
1038 fn rejects_unknown_time_format() {
1039 assert!(parse("@time 24").is_err());
1040 }
1041
1042 #[test]
1043 fn blank_line_inserts_feed() {
1044 let doc = parse("A\n\nB").unwrap();
1045 assert!(matches!(doc.blocks[1], Block::Feed(1)));
1046 }
1047
1048 #[test]
1049 fn whitespace_only_line_inserts_feed() {
1050 let doc = parse("A\n \nB").unwrap();
1051 assert!(matches!(doc.blocks[1], Block::Feed(1)));
1052 }
1053
1054 #[test]
1055 fn document_ends_with_cut_ignores_trailing_blank_lines() {
1056 let doc = parse("Line\n@cut\n\n").unwrap();
1057 assert!(document_ends_with_cut(&doc));
1058 }
1059
1060 #[test]
1061 fn document_without_cut_at_end() {
1062 let doc = parse("Line\n@feed 1").unwrap();
1063 assert!(!document_ends_with_cut(&doc));
1064 }
1065
1066 #[test]
1067 fn blank_line_between_barcode_and_qr_is_feed() {
1068 let doc = parse("@barcode RASTER CODE128 X\n\n:center:@qr RASTER Y scale=4").unwrap();
1069 assert!(matches!(
1070 doc.blocks.as_slice(),
1071 [
1072 Block::Barcode { .. },
1073 Block::Feed(1),
1074 Block::Qr { .. },
1075 ]
1076 ));
1077 }
1078
1079 #[test]
1080 fn dsl_marker_lines_are_not_feed() {
1081 for src in [
1082 ":left:\nNext",
1083 ":center:\nNext",
1084 ":right:\nNext",
1085 ":centre:\nNext",
1086 "# Title\n",
1087 "---\n",
1088 "@cut\n",
1089 ] {
1090 let doc = parse(src).unwrap();
1091 assert!(
1092 !doc.blocks.iter().any(|b| matches!(b, Block::Feed(1))),
1093 "unexpected feed for {src:?}"
1094 );
1095 }
1096 }
1097
1098 #[test]
1099 fn parses_raster_barcode() {
1100 let doc = parse("@barcode RASTER CODE128 ABC").unwrap();
1101 assert!(matches!(
1102 doc.blocks[0],
1103 Block::Barcode {
1104 mode: BarcodeMode::Raster,
1105 symbology: BarcodeSymbology::Code128,
1106 ..
1107 }
1108 ));
1109 }
1110}