BlueGit

timfa posprint

Files

posprint / src / dsl / parser.rs

parser.rs

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