BlueGit

timfa posprint

Files

posprint / src / dsl / parser.rs

parser.rs

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