use super::{ Align, BarcodeMode, BarcodeSymbology, Block, Document, ImageWidth, Inline, ParseError, QrEcc, QrMode, }; pub fn parse(source: &str) -> Result { let source = strip_comments(source); let mut blocks = Vec::new(); let mut lines = source.lines().peekable(); let mut line_no = 0usize; while let Some(raw_line) = lines.next() { line_no += 1; let line = raw_line.trim_end(); if line.trim().is_empty() { continue; } if line.starts_with('#') { blocks.push(parse_heading(line, line_no)?); continue; } if line.trim() == "---" { blocks.push(Block::Rule); continue; } if line.trim_start().starts_with('@') { blocks.push(parse_directive(line.trim(), line_no)?); continue; } let (align, first) = parse_align_prefix(line); let mut paragraph_lines = vec![first]; while let Some(&next) = lines.peek() { if next.trim().is_empty() || next.starts_with('#') || next.trim() == "---" || next.trim_start().starts_with('@') || starts_with_align_prefix(next) { break; } line_no += 1; lines.next(); paragraph_lines.push(next.trim_end().to_string()); } let text = paragraph_lines.join("\n"); blocks.push(Block::Paragraph { align, inlines: parse_inlines(&text, line_no, 1)?, }); } Ok(Document { blocks }) } fn strip_comments(source: &str) -> String { let mut out = String::with_capacity(source.len()); let mut chars = source.chars().peekable(); while let Some(ch) = chars.next() { if ch == '<' && chars.peek() == Some(&'!') { let mut rest: String = chars.clone().collect(); if rest.starts_with('!') { let _ = chars.next(); rest = chars.clone().collect(); if rest.starts_with("--") { for _ in 0..3 { chars.next(); } while let Some(c) = chars.next() { if c == '-' && chars.peek() == Some(&'-') { chars.next(); if chars.peek() == Some(&'>') { chars.next(); break; } } } continue; } } out.push('<'); } else { out.push(ch); } } out } fn starts_with_align_prefix(line: &str) -> bool { let t = line.trim_start(); t.starts_with(":left:") || t.starts_with(":center:") || t.starts_with(":right:") } fn parse_align_prefix(line: &str) -> (Align, String) { let trimmed = line.trim_start(); if let Some(rest) = trimmed.strip_prefix(":left:") { return (Align::Left, rest.trim_start().to_string()); } if let Some(rest) = trimmed.strip_prefix(":center:") { return (Align::Center, rest.trim_start().to_string()); } if let Some(rest) = trimmed.strip_prefix(":right:") { return (Align::Right, rest.trim_start().to_string()); } (Align::Left, line.to_string()) } fn parse_heading(line: &str, line_no: usize) -> Result { let mut level = 0u8; for ch in line.chars() { if ch == '#' { level += 1; } else { break; } } if level == 0 || level > 2 { return Err(err(line_no, 1, "heading must use # or ##")); } let text = line[level as usize..].trim(); if text.is_empty() { return Err(err(line_no, 1, "heading text is empty")); } Ok(Block::Heading { level, inlines: parse_inlines(text, line_no, level as usize + 1)?, }) } fn parse_directive(line: &str, line_no: usize) -> Result { let body = line .trim_start() .strip_prefix('@') .ok_or_else(|| err(line_no, 1, "expected directive"))?; let mut parts = body.split_whitespace(); let name = parts.next().unwrap_or("").to_ascii_lowercase(); match name.as_str() { "feed" => { let n = parts .next() .ok_or_else(|| err(line_no, 1, "@feed requires line count"))?; let lines: u8 = n .parse() .map_err(|_| err(line_no, 1, "@feed count must be 0-255"))?; Ok(Block::Feed(lines)) } "cut" => Ok(Block::Cut), "image" => parse_image_directive(parts.collect(), line_no), "barcode" => parse_barcode_directive(parts.collect(), line_no), "qr" => parse_qr_directive(parts.collect(), line_no), _ => Err(err(line_no, 1, format!("unknown directive @{name}"))), } } fn parse_image_directive(parts: Vec<&str>, line_no: usize) -> Result { if parts.is_empty() { return Err(err(line_no, 1, "@image requires a path")); } let path = parts[0].to_string(); let mut width = ImageWidth::Default; let mut align = Align::Left; for attr in &parts[1..] { if let Some((k, v)) = attr.split_once('=') { match k.to_ascii_lowercase().as_str() { "width" => { width = if let Some(p) = v.strip_suffix('%') { let pct: u8 = p .parse() .map_err(|_| err(line_no, 1, "invalid width percent"))?; ImageWidth::Percent(pct.min(100)) } else { let dots: u16 = v .parse() .map_err(|_| err(line_no, 1, "invalid width dots"))?; ImageWidth::Dots(dots) }; } "align" => align = parse_align_value(v, line_no)?, _ => return Err(err(line_no, 1, format!("unknown image attribute {k}"))), } } } Ok(Block::Image { path, width, align }) } fn parse_barcode_directive(parts: Vec<&str>, line_no: usize) -> Result { if parts.len() < 2 { return Err(err( line_no, 1, "@barcode requires symbology and data (or RASTER symbology data)", )); } let (mode, sym_idx, data_idx) = if parts[0].eq_ignore_ascii_case("RASTER") { if parts.len() < 3 { return Err(err( line_no, 1, "@barcode RASTER requires symbology and data", )); } (BarcodeMode::Raster, 1, 2) } else { (BarcodeMode::Native, 0, 1) }; let symbology = BarcodeSymbology::from_name(parts[sym_idx]) .ok_or_else(|| err(line_no, 1, format!("unknown barcode symbology {}", parts[sym_idx])))?; if mode == BarcodeMode::Native && !symbology.supports_native() { return Err(err( line_no, 1, format!( "{} has no native ESC/POS support; use RASTER {}", symbology.as_str(), symbology.as_str() ), )); } let data = parts[data_idx].to_string(); let attr_start = data_idx + 1; let mut height = 64u8; let mut align = Align::Left; let mut show_text = true; for attr in &parts[attr_start..] { if let Some((k, v)) = attr.split_once('=') { match k.to_ascii_lowercase().as_str() { "height" => { height = v .parse() .map_err(|_| err(line_no, 1, "invalid barcode height"))?; } "align" => align = parse_align_value(v, line_no)?, "show_text" => show_text = v == "true", _ => return Err(err(line_no, 1, format!("unknown barcode attribute {k}"))), } } } Ok(Block::Barcode { mode, symbology, data, height, align, show_text, }) } fn parse_qr_directive(parts: Vec<&str>, line_no: usize) -> Result { if parts.is_empty() { return Err(err(line_no, 1, "@qr requires data")); } let (mode, data_idx) = if parts[0].eq_ignore_ascii_case("RASTER") { if parts.len() < 2 { return Err(err(line_no, 1, "@qr RASTER requires data")); } (QrMode::Raster, 1) } else { (QrMode::Native, 0) }; let data = parts[data_idx].to_string(); let attr_start = data_idx + 1; let mut size = 4u8; let mut ecc = QrEcc::M; let mut align = Align::Left; let mut version = None; for attr in &parts[attr_start..] { if let Some((k, v)) = attr.split_once('=') { match k.to_ascii_lowercase().as_str() { "size" => { size = v .parse::() .map_err(|_| err(line_no, 1, "invalid qr size"))? .clamp(1, 16); } "scale" => { size = v .parse::() .map_err(|_| err(line_no, 1, "invalid qr scale"))? .clamp(1, 16); } "version" => { let ver: u8 = v .parse() .map_err(|_| err(line_no, 1, "invalid qr version"))?; if !(1..=40).contains(&ver) { return Err(err(line_no, 1, "qr version must be 1-40")); } version = Some(ver); } "ecc" => { ecc = QrEcc::from_name(v) .ok_or_else(|| err(line_no, 1, "qr ecc must be L, M, Q, or H"))?; } "align" => align = parse_align_value(v, line_no)?, _ => return Err(err(line_no, 1, format!("unknown qr attribute {k}"))), } } } Ok(Block::Qr { mode, data, size, ecc, version, align, }) } fn parse_align_value(value: &str, line_no: usize) -> Result { match value.to_ascii_lowercase().as_str() { "left" => Ok(Align::Left), "center" | "centre" => Ok(Align::Center), "right" => Ok(Align::Right), _ => Err(err(line_no, 1, "align must be left, center, or right")), } } fn parse_inlines(input: &str, line: usize, col: usize) -> Result, ParseError> { let mut out = Vec::new(); let mut i = 0usize; let chars: Vec = input.chars().collect(); while i < chars.len() { if chars[i] == '$' && i + 1 < chars.len() && chars[i + 1] == '{' { let start = i + 2; let mut j = start; while j < chars.len() && chars[j] != '}' { j += 1; } if j >= chars.len() { return Err(err(line, col + i, "unclosed parameter ${...}")); } let name: String = chars[start..j].iter().collect(); if !is_valid_param_name(&name) { return Err(err( line, col + i, format!("invalid parameter name '{name}'"), )); } out.push(Inline::Param(name)); i = j + 1; continue; } if chars[i] == '*' && i + 1 < chars.len() && chars[i + 1] == '*' { let (inner, next) = parse_delimited(&chars, i + 2, "**", line, col)?; out.push(Inline::Bold(parse_inlines(&inner, line, col + i + 2)?)); i = next; continue; } if chars[i] == '*' { let (inner, next) = parse_delimited(&chars, i + 1, "*", line, col)?; out.push(Inline::Italic(parse_inlines(&inner, line, col + i + 1)?)); i = next; continue; } if chars[i] == '`' { let (inner, next) = parse_delimited(&chars, i + 1, "`", line, col)?; out.push(Inline::Code(inner)); i = next; continue; } let start = i; while i < chars.len() && !matches!(chars[i], '$' | '*' | '`') && !(chars[i] == '$' && i + 1 < chars.len() && chars[i + 1] == '{') { if chars[i] == '$' { break; } if chars[i] == '*' || chars[i] == '`' { break; } i += 1; } if i == start { i += 1; continue; } out.push(Inline::Text(chars[start..i].iter().collect())); } Ok(out) } fn parse_delimited( chars: &[char], start: usize, marker: &str, line: usize, col: usize, ) -> Result<(String, usize), ParseError> { let mlen = marker.chars().count(); let mut i = start; while i < chars.len() { if chars[i..].iter().collect::().starts_with(marker) { let inner: String = chars[start..i].iter().collect(); return Ok((inner, i + mlen)); } i += 1; } Err(err( line, col + start, format!("unclosed delimiter '{marker}'"), )) } fn is_valid_param_name(name: &str) -> bool { let mut chars = name.chars(); match chars.next() { Some(c) if c.is_ascii_alphabetic() || c == '_' => {} _ => return false, } chars.all(|c| c.is_ascii_alphanumeric() || c == '_') } fn err(line: usize, column: usize, message: impl Into) -> ParseError { ParseError { line, column, message: message.into(), } } #[cfg(test)] mod tests { use super::*; use crate::dsl::{BarcodeMode, BarcodeSymbology, Inline}; #[test] fn parses_heading_and_paragraph() { let doc = parse("# Store\nHello **world**").unwrap(); assert_eq!(doc.blocks.len(), 2); assert!(matches!(doc.blocks[0], Block::Heading { level: 1, .. })); assert!(matches!(doc.blocks[1], Block::Paragraph { .. })); } #[test] fn parses_parameters() { let doc = parse("Order ${OrderId}").unwrap(); let Block::Paragraph { inlines, .. } = &doc.blocks[0] else { panic!("expected paragraph"); }; assert!(matches!( inlines.as_slice(), [ Inline::Text(_), Inline::Param(name) ] if name == "OrderId" )); } #[test] fn dedupes_collect_is_separate_module() { let doc = parse("@barcode CODE128 ${A}\n@qr ${A}").unwrap(); assert_eq!(doc.blocks.len(), 2); } #[test] fn strips_comments() { let doc = parse("\nVisible").unwrap(); assert_eq!(doc.blocks.len(), 1); } #[test] fn rejects_unknown_directive() { assert!(parse("@unknown x").is_err()); } #[test] fn parses_alignment_prefix() { let doc = parse(":center:\nCentered").unwrap(); let Block::Paragraph { align, .. } = &doc.blocks[0] else { panic!(); }; assert_eq!(*align, Align::Center); } #[test] fn parses_raster_barcode() { let doc = parse("@barcode RASTER CODE128 ABC").unwrap(); assert!(matches!( doc.blocks[0], Block::Barcode { mode: BarcodeMode::Raster, symbology: BarcodeSymbology::Code128, .. } )); } }