BlueGit

timfa posprint

Files

posprint / src / dsl / parser.rs

parser.rs

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