BlueGit

timfa posprint

Files

posprint / src / dsl / parser.rs

parser.rs

cfe7435b History
parser.rs 27.5 KiB Download Raw
1use super::{
2 Align, BarcodeMode, BarcodeSymbology, Block, Document, ImageWidth, Inline, ParseError, QrEcc,
3 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_inlines(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_inlines(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 Ok(Document { blocks })
117}
118
119/// True when the last substantive block is `@cut` (trailing blank-line feeds are ignored).
120pub fn document_ends_with_cut(document: &Document) -> bool {
121 for block in document.blocks.iter().rev() {
122 match block {
123 Block::Feed(_) => continue,
124 Block::Cut => return true,
125 _ => return false,
126 }
127 }
128 false
129}
130
131fn strip_comments(source: &str) -> String {
132 let mut out = String::with_capacity(source.len());
133 let mut chars = source.chars().peekable();
134 while let Some(ch) = chars.next() {
135 if ch == '<' && chars.peek() == Some(&'!') {
136 let mut rest: String = chars.clone().collect();
137 if rest.starts_with('!') {
138 let _ = chars.next();
139 rest = chars.clone().collect();
140 if rest.starts_with("--") {
141 for _ in 0..3 {
142 chars.next();
143 }
144 while let Some(c) = chars.next() {
145 if c == '-' && chars.peek() == Some(&'-') {
146 chars.next();
147 if chars.peek() == Some(&'>') {
148 chars.next();
149 break;
150 }
151 }
152 }
153 continue;
154 }
155 }
156 out.push('<');
157 } else {
158 out.push(ch);
159 }
160 }
161 out
162}
163
164/// Parse `:left:`, `:center:`, `:centre:`, or `:right:` at line start.
165/// Returns the alignment and optional remaining content on the same line.
166fn parse_align_line(line: &str) -> Option<(Align, Option<&str>)> {
167 let trimmed = line.trim_start();
168 if let Some(rest) = trimmed.strip_prefix(":left:") {
169 let rest = rest.trim_start();
170 return Some((
171 Align::Left,
172 if rest.is_empty() { None } else { Some(rest) },
173 ));
174 }
175 if let Some(rest) = trimmed.strip_prefix(":center:") {
176 let rest = rest.trim_start();
177 return Some((
178 Align::Center,
179 if rest.is_empty() { None } else { Some(rest) },
180 ));
181 }
182 if let Some(rest) = trimmed.strip_prefix(":centre:") {
183 let rest = rest.trim_start();
184 return Some((
185 Align::Center,
186 if rest.is_empty() { None } else { Some(rest) },
187 ));
188 }
189 if let Some(rest) = trimmed.strip_prefix(":right:") {
190 let rest = rest.trim_start();
191 return Some((
192 Align::Right,
193 if rest.is_empty() { None } else { Some(rest) },
194 ));
195 }
196 None
197}
198
199/// Split line content on embedded `:left:`, `:center:`, `:centre:`, or `:right:` markers.
200fn split_aligned_segments(content: &str, start_align: Align) -> Vec<(Align, String)> {
201 let mut segments = Vec::new();
202 let mut align = start_align;
203 let mut rest = content;
204
205 while let Some((pos, new_align, marker_len)) = find_next_align_marker(rest) {
206 let before = rest[..pos].trim();
207 if !before.is_empty() {
208 segments.push((align, before.to_string()));
209 }
210 align = new_align;
211 rest = rest[pos + marker_len..].trim_start();
212 }
213
214 let tail = rest.trim();
215 if !tail.is_empty() {
216 segments.push((align, tail.to_string()));
217 }
218 segments
219}
220
221fn find_next_align_marker(s: &str) -> Option<(usize, Align, usize)> {
222 const MARKERS: &[(&str, Align)] = &[
223 (":left:", Align::Left),
224 (":center:", Align::Center),
225 (":centre:", Align::Center),
226 (":right:", Align::Right),
227 ];
228
229 let mut best: Option<(usize, Align, usize)> = None;
230 for (pat, marker_align) in MARKERS {
231 if let Some(pos) = s.find(pat) {
232 if best.is_none() || pos < best.unwrap().0 {
233 best = Some((pos, *marker_align, pat.len()));
234 }
235 }
236 }
237 best
238}
239
240/// True only when a line has no visible content (empty or whitespace-only).
241/// Lines with DSL markers (`:right:`, `@feed`, `#`, etc.) are never feed lines.
242fn is_blank_feed_line(line: &str) -> bool {
243 line.chars().all(|c| c.is_whitespace())
244}
245
246fn parse_heading(line: &str, line_no: usize, align: Align) -> Result<Block, ParseError> {
247 let mut level = 0u8;
248 for ch in line.chars() {
249 if ch == '#' {
250 level += 1;
251 } else {
252 break;
253 }
254 }
255 if level == 0 || level > 2 {
256 return Err(err(line_no, 1, "heading must use # or ##"));
257 }
258 let text = line[level as usize..].trim();
259 if text.is_empty() {
260 return Err(err(line_no, 1, "heading text is empty"));
261 }
262 Ok(Block::Heading {
263 level,
264 align,
265 inlines: parse_inlines(text, line_no, level as usize + 1)?,
266 })
267}
268
269fn parse_directive(line: &str, line_no: usize, default_align: Align) -> Result<Block, ParseError> {
270 let body = line
271 .trim_start()
272 .strip_prefix('@')
273 .ok_or_else(|| err(line_no, 1, "expected directive"))?;
274 let mut parts = body.split_whitespace();
275 let name = parts.next().unwrap_or("").to_ascii_lowercase();
276 match name.as_str() {
277 "feed" => {
278 let n = parts
279 .next()
280 .ok_or_else(|| err(line_no, 1, "@feed requires line count"))?;
281 let lines: u8 = n
282 .parse()
283 .map_err(|_| err(line_no, 1, "@feed count must be 0-255"))?;
284 Ok(Block::Feed(lines))
285 }
286 "cut" => Ok(Block::Cut),
287 "image" => parse_image_directive(parts.collect(), line_no, default_align),
288 "barcode" => parse_barcode_directive(parts.collect(), line_no, default_align),
289 "qr" => parse_qr_directive(parts.collect(), line_no, default_align),
290 "date" => parse_date_directive(parts.collect(), line_no, default_align),
291 "time" => parse_time_directive(parts.collect(), line_no, default_align),
292 _ => Err(err(line_no, 1, format!("unknown directive @{name}"))),
293 }
294}
295
296fn parse_image_directive(
297 parts: Vec<&str>,
298 line_no: usize,
299 default_align: Align,
300) -> Result<Block, ParseError> {
301 if parts.is_empty() {
302 return Err(err(line_no, 1, "@image requires a path"));
303 }
304 let path = parts[0].to_string();
305 let mut width = ImageWidth::Default;
306 let mut align = default_align;
307 for attr in &parts[1..] {
308 if let Some((k, v)) = attr.split_once('=') {
309 match k.to_ascii_lowercase().as_str() {
310 "width" => {
311 width = if let Some(p) = v.strip_suffix('%') {
312 let pct: u8 = p
313 .parse()
314 .map_err(|_| err(line_no, 1, "invalid width percent"))?;
315 ImageWidth::Percent(pct.min(100))
316 } else {
317 let dots: u16 = v
318 .parse()
319 .map_err(|_| err(line_no, 1, "invalid width dots"))?;
320 ImageWidth::Dots(dots)
321 };
322 }
323 "align" => align = parse_align_value(v, line_no)?,
324 _ => return Err(err(line_no, 1, format!("unknown image attribute {k}"))),
325 }
326 }
327 }
328 Ok(Block::Image { path, width, align })
329}
330
331fn parse_barcode_directive(
332 parts: Vec<&str>,
333 line_no: usize,
334 default_align: Align,
335) -> Result<Block, ParseError> {
336 if parts.len() < 2 {
337 return Err(err(
338 line_no,
339 1,
340 "@barcode requires symbology and data (or RASTER symbology data)",
341 ));
342 }
343
344 let (mode, sym_idx, data_idx) = if parts[0].eq_ignore_ascii_case("RASTER") {
345 if parts.len() < 3 {
346 return Err(err(
347 line_no,
348 1,
349 "@barcode RASTER requires symbology and data",
350 ));
351 }
352 (BarcodeMode::Raster, 1, 2)
353 } else {
354 (BarcodeMode::Native, 0, 1)
355 };
356
357 let symbology = BarcodeSymbology::from_name(parts[sym_idx])
358 .ok_or_else(|| err(line_no, 1, format!("unknown barcode symbology {}", parts[sym_idx])))?;
359
360 if mode == BarcodeMode::Native && !symbology.supports_native() {
361 return Err(err(
362 line_no,
363 1,
364 format!(
365 "{} has no native ESC/POS support; use RASTER {}",
366 symbology.as_str(),
367 symbology.as_str()
368 ),
369 ));
370 }
371
372 let data = parts[data_idx].to_string();
373 let attr_start = data_idx + 1;
374 let mut height = 64u8;
375 let mut align = default_align;
376 let mut show_text = true;
377 for attr in &parts[attr_start..] {
378 if let Some((k, v)) = attr.split_once('=') {
379 match k.to_ascii_lowercase().as_str() {
380 "height" => {
381 height = v
382 .parse()
383 .map_err(|_| err(line_no, 1, "invalid barcode height"))?;
384 }
385 "align" => align = parse_align_value(v, line_no)?,
386 "show_text" => show_text = v == "true",
387 _ => return Err(err(line_no, 1, format!("unknown barcode attribute {k}"))),
388 }
389 }
390 }
391 Ok(Block::Barcode {
392 mode,
393 symbology,
394 data,
395 height,
396 align,
397 show_text,
398 })
399}
400
401fn parse_date_directive(
402 parts: Vec<&str>,
403 _line_no: usize,
404 default_align: Align,
405) -> Result<Block, ParseError> {
406 let pattern = parts.join(" ");
407 let format = if pattern.is_empty() {
408 None
409 } else {
410 Some(pattern)
411 };
412 Ok(Block::Date {
413 format,
414 align: default_align,
415 })
416}
417
418fn parse_time_directive(
419 parts: Vec<&str>,
420 line_no: usize,
421 default_align: Align,
422) -> Result<Block, ParseError> {
423 use super::TimeFormatSpec;
424 let spec = match parts.first().map(|s| s.to_ascii_lowercase()).as_deref() {
425 None => TimeFormatSpec::Hours24,
426 Some("12h") => TimeFormatSpec::Hours12,
427 Some("24h") => TimeFormatSpec::Hours24,
428 Some(other) => {
429 return Err(err(
430 line_no,
431 1,
432 format!("unknown @time format '{other}' (use 12h or 24h)"),
433 ));
434 }
435 };
436 if parts.len() > 1 {
437 return Err(err(
438 line_no,
439 1,
440 "@time accepts at most one format argument (12h or 24h)",
441 ));
442 }
443 Ok(Block::Time {
444 format: spec,
445 align: default_align,
446 })
447}
448
449fn parse_qr_directive(
450 parts: Vec<&str>,
451 line_no: usize,
452 default_align: Align,
453) -> Result<Block, ParseError> {
454 if parts.is_empty() {
455 return Err(err(line_no, 1, "@qr requires data"));
456 }
457
458 let (mode, data_idx) = if parts[0].eq_ignore_ascii_case("RASTER") {
459 if parts.len() < 2 {
460 return Err(err(line_no, 1, "@qr RASTER requires data"));
461 }
462 (QrMode::Raster, 1)
463 } else {
464 (QrMode::Native, 0)
465 };
466
467 let data = parts[data_idx].to_string();
468 let attr_start = data_idx + 1;
469 let mut size = 4u8;
470 let mut ecc = QrEcc::M;
471 let mut align = default_align;
472 let mut version = None;
473 for attr in &parts[attr_start..] {
474 if let Some((k, v)) = attr.split_once('=') {
475 match k.to_ascii_lowercase().as_str() {
476 "size" => {
477 size = v
478 .parse::<u8>()
479 .map_err(|_| err(line_no, 1, "invalid qr size"))?
480 .clamp(1, 16);
481 }
482 "scale" => {
483 size = v
484 .parse::<u8>()
485 .map_err(|_| err(line_no, 1, "invalid qr scale"))?
486 .clamp(1, 16);
487 }
488 "version" => {
489 let ver: u8 = v
490 .parse()
491 .map_err(|_| err(line_no, 1, "invalid qr version"))?;
492 if !(1..=40).contains(&ver) {
493 return Err(err(line_no, 1, "qr version must be 1-40"));
494 }
495 version = Some(ver);
496 }
497 "ecc" => {
498 ecc = QrEcc::from_name(v)
499 .ok_or_else(|| err(line_no, 1, "qr ecc must be L, M, Q, or H"))?;
500 }
501 "align" => align = parse_align_value(v, line_no)?,
502 _ => return Err(err(line_no, 1, format!("unknown qr attribute {k}"))),
503 }
504 }
505 }
506 Ok(Block::Qr {
507 mode,
508 data,
509 size,
510 ecc,
511 version,
512 align,
513 })
514}
515
516fn parse_align_value(value: &str, line_no: usize) -> Result<Align, ParseError> {
517 match value.to_ascii_lowercase().as_str() {
518 "left" => Ok(Align::Left),
519 "center" | "centre" => Ok(Align::Center),
520 "right" => Ok(Align::Right),
521 _ => Err(err(line_no, 1, "align must be left, center, or right")),
522 }
523}
524
525fn is_list_item_line(line: &str) -> bool {
526 line.trim_start().starts_with("- ")
527}
528
529fn list_item_text(line: &str) -> &str {
530 line.trim_start()
531 .strip_prefix("- ")
532 .map(str::trim_end)
533 .unwrap_or(line.trim_end())
534}
535
536fn parse_list_item_inlines(line: &str, line_no: usize) -> Result<Vec<Inline>, ParseError> {
537 parse_inlines(list_item_text(line), line_no, 1)
538}
539
540fn parse_inlines(input: &str, line: usize, col: usize) -> Result<Vec<Inline>, ParseError> {
541 let mut out = Vec::new();
542 let mut i = 0usize;
543 let chars: Vec<char> = input.chars().collect();
544 while i < chars.len() {
545 if chars[i] == '$' && i + 1 < chars.len() && chars[i + 1] == '{' {
546 let start = i + 2;
547 let mut j = start;
548 while j < chars.len() && chars[j] != '}' {
549 j += 1;
550 }
551 if j >= chars.len() {
552 return Err(err(line, col + i, "unclosed parameter ${...}"));
553 }
554 let name: String = chars[start..j].iter().collect();
555 if !is_valid_param_name(&name) {
556 return Err(err(
557 line,
558 col + i,
559 format!("invalid parameter name '{name}'"),
560 ));
561 }
562 out.push(Inline::Param(name));
563 i = j + 1;
564 continue;
565 }
566 let start = i;
567 while i < chars.len() && chars[i] != '$' {
568 i += 1;
569 }
570 if i == start {
571 i += 1;
572 continue;
573 }
574 out.push(Inline::Text(chars[start..i].iter().collect()));
575 }
576 Ok(out)
577}
578
579fn is_valid_param_name(name: &str) -> bool {
580 let mut chars = name.chars();
581 match chars.next() {
582 Some(c) if c.is_ascii_alphabetic() || c == '_' => {}
583 _ => return false,
584 }
585 chars.all(|c| c.is_ascii_alphanumeric() || c == '_')
586}
587
588fn err(line: usize, column: usize, message: impl Into<String>) -> ParseError {
589 ParseError {
590 line,
591 column,
592 message: message.into(),
593 }
594}
595
596#[cfg(test)]
597mod tests {
598 use super::*;
599 use crate::dsl::{BarcodeMode, BarcodeSymbology, Inline, TimeFormatSpec};
600
601 fn inlines_to_text(inlines: &[Inline]) -> String {
602 let mut out = String::new();
603 for inline in inlines {
604 match inline {
605 Inline::Text(t) | Inline::Param(t) => out.push_str(t),
606 }
607 }
608 out
609 }
610
611 #[test]
612 fn parses_heading_and_paragraph() {
613 let doc = parse("# Store\nHello world").unwrap();
614 assert_eq!(doc.blocks.len(), 2);
615 assert!(matches!(doc.blocks[0], Block::Heading { level: 1, .. }));
616 assert!(matches!(doc.blocks[1], Block::Paragraph { .. }));
617 }
618
619 #[test]
620 fn parses_bullet_list() {
621 let doc = parse("- this\n- is then\n- a list").unwrap();
622 assert_eq!(doc.blocks.len(), 1);
623 let Block::List { items, .. } = &doc.blocks[0] else {
624 panic!("expected list");
625 };
626 assert_eq!(items.len(), 3);
627 assert_eq!(inlines_to_text(&items[0]), "this");
628 assert_eq!(inlines_to_text(&items[1]), "is then");
629 assert_eq!(inlines_to_text(&items[2]), "a list");
630 }
631
632 #[test]
633 fn blank_line_breaks_bullet_list() {
634 let doc = parse("- one\n\n- two").unwrap();
635 assert_eq!(doc.blocks.len(), 3);
636 assert!(matches!(doc.blocks[0], Block::List { .. }));
637 assert!(matches!(doc.blocks[1], Block::Feed(1)));
638 assert!(matches!(doc.blocks[2], Block::List { .. }));
639 }
640
641 #[test]
642 fn parses_parameters() {
643 let doc = parse("Order ${OrderId}").unwrap();
644 let Block::Paragraph { inlines, .. } = &doc.blocks[0] else {
645 panic!("expected paragraph");
646 };
647 assert!(matches!(
648 inlines.as_slice(),
649 [
650 Inline::Text(_),
651 Inline::Param(name)
652 ] if name == "OrderId"
653 ));
654 }
655
656 #[test]
657 fn dedupes_collect_is_separate_module() {
658 let doc = parse("@barcode CODE128 ${A}\n@qr ${A}").unwrap();
659 assert_eq!(doc.blocks.len(), 2);
660 }
661
662 #[test]
663 fn strips_comments() {
664 let doc = parse("<!-- hidden -->Visible").unwrap();
665 assert_eq!(doc.blocks.len(), 1);
666 let doc = parse("<!-- hidden -->\nVisible").unwrap();
667 assert!(matches!(doc.blocks[0], Block::Feed(1)));
668 }
669
670 #[test]
671 fn rejects_unknown_directive() {
672 assert!(parse("@unknown x").is_err());
673 }
674
675 #[test]
676 fn parses_alignment_prefix() {
677 let doc = parse(":center:\nCentered").unwrap();
678 let Block::Paragraph { align, .. } = &doc.blocks[0] else {
679 panic!();
680 };
681 assert_eq!(*align, Align::Center);
682 }
683
684 #[test]
685 fn persistent_center_applies_to_heading_and_directives() {
686 let doc = parse(
687 ":center:\n# Hello\n@qr ${Data}\n@barcode RASTER CODE128 ${Data}\n:left:\nLeft\n",
688 )
689 .unwrap();
690 assert_eq!(doc.blocks.len(), 4);
691 assert!(matches!(
692 doc.blocks[0],
693 Block::Heading {
694 align: Align::Center,
695 ..
696 }
697 ));
698 assert!(matches!(
699 doc.blocks[1],
700 Block::Qr {
701 align: Align::Center,
702 ..
703 }
704 ));
705 assert!(matches!(
706 doc.blocks[2],
707 Block::Barcode {
708 align: Align::Center,
709 ..
710 }
711 ));
712 assert!(matches!(
713 doc.blocks[3],
714 Block::Paragraph {
715 align: Align::Left,
716 ..
717 }
718 ));
719 }
720
721 #[test]
722 fn persistent_center_groups_following_paragraph_lines() {
723 let doc = parse(":center:\nLine one\nLine two").unwrap();
724 assert_eq!(doc.blocks.len(), 1);
725 let Block::Paragraph { align, inlines } = &doc.blocks[0] else {
726 panic!();
727 };
728 assert_eq!(*align, Align::Center);
729 assert_eq!(inlines_to_text(inlines), "Line one\nLine two");
730 }
731
732 #[test]
733 fn align_prefix_on_same_line_sets_persistent_state() {
734 let doc = parse(":center: Inline\nNext").unwrap();
735 assert_eq!(doc.blocks.len(), 1);
736 let Block::Paragraph { align, inlines } = &doc.blocks[0] else {
737 panic!();
738 };
739 assert_eq!(*align, Align::Center);
740 assert_eq!(inlines_to_text(inlines), "Inline\nNext");
741 }
742
743 #[test]
744 fn multiple_align_prefixes_on_one_line() {
745 let doc = parse(":left:left :right:right").unwrap();
746 assert_eq!(doc.blocks.len(), 2);
747 assert!(matches!(
748 doc.blocks[0],
749 Block::Paragraph {
750 align: Align::Left,
751 ..
752 }
753 ));
754 assert!(matches!(
755 doc.blocks[1],
756 Block::Paragraph {
757 align: Align::Right,
758 ..
759 }
760 ));
761 let Block::Paragraph { inlines: left, .. } = &doc.blocks[0] else {
762 panic!();
763 };
764 let Block::Paragraph { inlines: right, .. } = &doc.blocks[1] else {
765 panic!();
766 };
767 assert_eq!(inlines_to_text(left), "left");
768 assert_eq!(inlines_to_text(right), "right");
769 }
770
771 #[test]
772 fn align_only_line_does_not_emit_block() {
773 let doc = parse(":center:\n:center:").unwrap();
774 assert!(doc.blocks.is_empty());
775 }
776
777 #[test]
778 fn parses_date_and_time_directives() {
779 let doc = parse("@date\n@date DD-YYYY-MM\n@time\n@time 12h").unwrap();
780 assert!(matches!(
781 doc.blocks[0],
782 Block::Date {
783 format: None,
784 ..
785 }
786 ));
787 assert!(matches!(
788 doc.blocks[1],
789 Block::Date {
790 format: Some(ref f),
791 ..
792 } if f == "DD-YYYY-MM"
793 ));
794 assert!(matches!(
795 doc.blocks[2],
796 Block::Time {
797 format: TimeFormatSpec::Hours24,
798 ..
799 }
800 ));
801 assert!(matches!(
802 doc.blocks[3],
803 Block::Time {
804 format: TimeFormatSpec::Hours12,
805 ..
806 }
807 ));
808 }
809
810 #[test]
811 fn rejects_unknown_time_format() {
812 assert!(parse("@time 24").is_err());
813 }
814
815 #[test]
816 fn blank_line_inserts_feed() {
817 let doc = parse("A\n\nB").unwrap();
818 assert!(matches!(doc.blocks[1], Block::Feed(1)));
819 }
820
821 #[test]
822 fn whitespace_only_line_inserts_feed() {
823 let doc = parse("A\n \nB").unwrap();
824 assert!(matches!(doc.blocks[1], Block::Feed(1)));
825 }
826
827 #[test]
828 fn document_ends_with_cut_ignores_trailing_blank_lines() {
829 let doc = parse("Line\n@cut\n\n").unwrap();
830 assert!(document_ends_with_cut(&doc));
831 }
832
833 #[test]
834 fn document_without_cut_at_end() {
835 let doc = parse("Line\n@feed 1").unwrap();
836 assert!(!document_ends_with_cut(&doc));
837 }
838
839 #[test]
840 fn blank_line_between_barcode_and_qr_is_feed() {
841 let doc = parse("@barcode RASTER CODE128 X\n\n:center:@qr RASTER Y scale=4").unwrap();
842 assert!(matches!(
843 doc.blocks.as_slice(),
844 [
845 Block::Barcode { .. },
846 Block::Feed(1),
847 Block::Qr { .. },
848 ]
849 ));
850 }
851
852 #[test]
853 fn dsl_marker_lines_are_not_feed() {
854 for src in [
855 ":left:\nNext",
856 ":center:\nNext",
857 ":right:\nNext",
858 ":centre:\nNext",
859 "# Title\n",
860 "---\n",
861 "@cut\n",
862 ] {
863 let doc = parse(src).unwrap();
864 assert!(
865 !doc.blocks.iter().any(|b| matches!(b, Block::Feed(1))),
866 "unexpected feed for {src:?}"
867 );
868 }
869 }
870
871 #[test]
872 fn parses_raster_barcode() {
873 let doc = parse("@barcode RASTER CODE128 ABC").unwrap();
874 assert!(matches!(
875 doc.blocks[0],
876 Block::Barcode {
877 mode: BarcodeMode::Raster,
878 symbology: BarcodeSymbology::Code128,
879 ..
880 }
881 ));
882 }
883}