BlueGit

timfa posprint

Files

posprint / src / dsl / parser.rs

parser.rs

parser.rs 14.2 KiB Download Raw
1use super::{
2 Align, BarcodeSymbology, Block, Document, ImageWidth, Inline, ParseError, QrEcc,
3};
4
5pub fn parse(source: &str) -> Result<Document, ParseError> {
6 let source = strip_comments(source);
7 let mut blocks = Vec::new();
8 let mut lines = source.lines().peekable();
9 let mut line_no = 0usize;
10
11 while let Some(raw_line) = lines.next() {
12 line_no += 1;
13 let line = raw_line.trim_end();
14 if line.trim().is_empty() {
15 continue;
16 }
17
18 if line.starts_with('#') {
19 blocks.push(parse_heading(line, line_no)?);
20 continue;
21 }
22
23 if line.trim() == "---" {
24 blocks.push(Block::Rule);
25 continue;
26 }
27
28 if line.trim_start().starts_with('@') {
29 blocks.push(parse_directive(line.trim(), line_no)?);
30 continue;
31 }
32
33 let (align, first) = parse_align_prefix(line);
34 let mut paragraph_lines = vec![first];
35 while let Some(&next) = lines.peek() {
36 if next.trim().is_empty()
37 || next.starts_with('#')
38 || next.trim() == "---"
39 || next.trim_start().starts_with('@')
40 || starts_with_align_prefix(next)
41 {
42 break;
43 }
44 line_no += 1;
45 lines.next();
46 paragraph_lines.push(next.trim_end().to_string());
47 }
48 let text = paragraph_lines.join("\n");
49 blocks.push(Block::Paragraph {
50 align,
51 inlines: parse_inlines(&text, line_no, 1)?,
52 });
53 }
54
55 Ok(Document { blocks })
56}
57
58fn strip_comments(source: &str) -> String {
59 let mut out = String::with_capacity(source.len());
60 let mut chars = source.chars().peekable();
61 while let Some(ch) = chars.next() {
62 if ch == '<' && chars.peek() == Some(&'!') {
63 let mut rest: String = chars.clone().collect();
64 if rest.starts_with('!') {
65 let _ = chars.next();
66 rest = chars.clone().collect();
67 if rest.starts_with("--") {
68 for _ in 0..3 {
69 chars.next();
70 }
71 while let Some(c) = chars.next() {
72 if c == '-' && chars.peek() == Some(&'-') {
73 chars.next();
74 if chars.peek() == Some(&'>') {
75 chars.next();
76 break;
77 }
78 }
79 }
80 continue;
81 }
82 }
83 out.push('<');
84 } else {
85 out.push(ch);
86 }
87 }
88 out
89}
90
91fn starts_with_align_prefix(line: &str) -> bool {
92 let t = line.trim_start();
93 t.starts_with(":left:")
94 || t.starts_with(":center:")
95 || t.starts_with(":right:")
96}
97
98fn parse_align_prefix(line: &str) -> (Align, String) {
99 let trimmed = line.trim_start();
100 if let Some(rest) = trimmed.strip_prefix(":left:") {
101 return (Align::Left, rest.trim_start().to_string());
102 }
103 if let Some(rest) = trimmed.strip_prefix(":center:") {
104 return (Align::Center, rest.trim_start().to_string());
105 }
106 if let Some(rest) = trimmed.strip_prefix(":right:") {
107 return (Align::Right, rest.trim_start().to_string());
108 }
109 (Align::Left, line.to_string())
110}
111
112fn parse_heading(line: &str, line_no: usize) -> Result<Block, ParseError> {
113 let mut level = 0u8;
114 for ch in line.chars() {
115 if ch == '#' {
116 level += 1;
117 } else {
118 break;
119 }
120 }
121 if level == 0 || level > 2 {
122 return Err(err(line_no, 1, "heading must use # or ##"));
123 }
124 let text = line[level as usize..].trim();
125 if text.is_empty() {
126 return Err(err(line_no, 1, "heading text is empty"));
127 }
128 Ok(Block::Heading {
129 level,
130 inlines: parse_inlines(text, line_no, level as usize + 1)?,
131 })
132}
133
134fn parse_directive(line: &str, line_no: usize) -> Result<Block, ParseError> {
135 let body = line
136 .trim_start()
137 .strip_prefix('@')
138 .ok_or_else(|| err(line_no, 1, "expected directive"))?;
139 let mut parts = body.split_whitespace();
140 let name = parts.next().unwrap_or("").to_ascii_lowercase();
141 match name.as_str() {
142 "feed" => {
143 let n = parts
144 .next()
145 .ok_or_else(|| err(line_no, 1, "@feed requires line count"))?;
146 let lines: u8 = n
147 .parse()
148 .map_err(|_| err(line_no, 1, "@feed count must be 0-255"))?;
149 Ok(Block::Feed(lines))
150 }
151 "cut" => Ok(Block::Cut),
152 "image" => parse_image_directive(parts.collect(), line_no),
153 "barcode" => parse_barcode_directive(parts.collect(), line_no),
154 "qr" => parse_qr_directive(parts.collect(), line_no),
155 _ => Err(err(line_no, 1, format!("unknown directive @{name}"))),
156 }
157}
158
159fn parse_image_directive(parts: Vec<&str>, line_no: usize) -> Result<Block, ParseError> {
160 if parts.is_empty() {
161 return Err(err(line_no, 1, "@image requires a path"));
162 }
163 let path = parts[0].to_string();
164 let mut width = ImageWidth::Default;
165 let mut align = Align::Left;
166 for attr in &parts[1..] {
167 if let Some((k, v)) = attr.split_once('=') {
168 match k.to_ascii_lowercase().as_str() {
169 "width" => {
170 width = if let Some(p) = v.strip_suffix('%') {
171 let pct: u8 = p
172 .parse()
173 .map_err(|_| err(line_no, 1, "invalid width percent"))?;
174 ImageWidth::Percent(pct.min(100))
175 } else {
176 let dots: u16 = v
177 .parse()
178 .map_err(|_| err(line_no, 1, "invalid width dots"))?;
179 ImageWidth::Dots(dots)
180 };
181 }
182 "align" => align = parse_align_value(v, line_no)?,
183 _ => return Err(err(line_no, 1, format!("unknown image attribute {k}"))),
184 }
185 }
186 }
187 Ok(Block::Image { path, width, align })
188}
189
190fn parse_barcode_directive(parts: Vec<&str>, line_no: usize) -> Result<Block, ParseError> {
191 if parts.len() < 2 {
192 return Err(err(
193 line_no,
194 1,
195 "@barcode requires symbology and data",
196 ));
197 }
198 let symbology = match parts[0].to_ascii_uppercase().as_str() {
199 "CODE128" => BarcodeSymbology::Code128,
200 "EAN13" => BarcodeSymbology::Ean13,
201 "EAN8" => BarcodeSymbology::Ean8,
202 "CODE39" => BarcodeSymbology::Code39,
203 other => return Err(err(line_no, 1, format!("unknown barcode symbology {other}"))),
204 };
205 let data = parts[1].to_string();
206 let mut height = 64u8;
207 let mut align = Align::Left;
208 let mut show_text = true;
209 for attr in &parts[2..] {
210 if let Some((k, v)) = attr.split_once('=') {
211 match k.to_ascii_lowercase().as_str() {
212 "height" => {
213 height = v
214 .parse()
215 .map_err(|_| err(line_no, 1, "invalid barcode height"))?;
216 }
217 "align" => align = parse_align_value(v, line_no)?,
218 "show_text" => {
219 show_text = v == "true";
220 }
221 _ => return Err(err(line_no, 1, format!("unknown barcode attribute {k}"))),
222 }
223 }
224 }
225 Ok(Block::Barcode {
226 symbology,
227 data,
228 height,
229 align,
230 show_text,
231 })
232}
233
234fn parse_qr_directive(parts: Vec<&str>, line_no: usize) -> Result<Block, ParseError> {
235 if parts.is_empty() {
236 return Err(err(line_no, 1, "@qr requires data"));
237 }
238 let data = parts[0].to_string();
239 let mut size = 4u8;
240 let mut ecc = QrEcc::M;
241 let mut align = Align::Left;
242 for attr in &parts[1..] {
243 if let Some((k, v)) = attr.split_once('=') {
244 match k.to_ascii_lowercase().as_str() {
245 "size" => {
246 size = v
247 .parse::<u8>()
248 .map_err(|_| err(line_no, 1, "invalid qr size"))?
249 .clamp(1, 16);
250 }
251 "ecc" => {
252 ecc = match v.to_ascii_uppercase().as_str() {
253 "L" => QrEcc::L,
254 "M" => QrEcc::M,
255 "Q" => QrEcc::Q,
256 "H" => QrEcc::H,
257 _ => return Err(err(line_no, 1, "qr ecc must be L, M, Q, or H")),
258 };
259 }
260 "align" => align = parse_align_value(v, line_no)?,
261 _ => return Err(err(line_no, 1, format!("unknown qr attribute {k}"))),
262 }
263 }
264 }
265 Ok(Block::Qr {
266 data,
267 size,
268 ecc,
269 align,
270 })
271}
272
273fn parse_align_value(value: &str, line_no: usize) -> Result<Align, ParseError> {
274 match value.to_ascii_lowercase().as_str() {
275 "left" => Ok(Align::Left),
276 "center" | "centre" => Ok(Align::Center),
277 "right" => Ok(Align::Right),
278 _ => Err(err(line_no, 1, "align must be left, center, or right")),
279 }
280}
281
282fn parse_inlines(input: &str, line: usize, col: usize) -> Result<Vec<Inline>, ParseError> {
283 let mut out = Vec::new();
284 let mut i = 0usize;
285 let chars: Vec<char> = input.chars().collect();
286 while i < chars.len() {
287 if chars[i] == '$' && i + 1 < chars.len() && chars[i + 1] == '{' {
288 let start = i + 2;
289 let mut j = start;
290 while j < chars.len() && chars[j] != '}' {
291 j += 1;
292 }
293 if j >= chars.len() {
294 return Err(err(line, col + i, "unclosed parameter ${...}"));
295 }
296 let name: String = chars[start..j].iter().collect();
297 if !is_valid_param_name(&name) {
298 return Err(err(
299 line,
300 col + i,
301 format!("invalid parameter name '{name}'"),
302 ));
303 }
304 out.push(Inline::Param(name));
305 i = j + 1;
306 continue;
307 }
308 if chars[i] == '*' && i + 1 < chars.len() && chars[i + 1] == '*' {
309 let (inner, next) = parse_delimited(&chars, i + 2, "**", line, col)?;
310 out.push(Inline::Bold(parse_inlines(&inner, line, col + i + 2)?));
311 i = next;
312 continue;
313 }
314 if chars[i] == '*' {
315 let (inner, next) = parse_delimited(&chars, i + 1, "*", line, col)?;
316 out.push(Inline::Italic(parse_inlines(&inner, line, col + i + 1)?));
317 i = next;
318 continue;
319 }
320 if chars[i] == '`' {
321 let (inner, next) = parse_delimited(&chars, i + 1, "`", line, col)?;
322 out.push(Inline::Code(inner));
323 i = next;
324 continue;
325 }
326 let start = i;
327 while i < chars.len()
328 && !matches!(chars[i], '$' | '*' | '`')
329 && !(chars[i] == '$' && i + 1 < chars.len() && chars[i + 1] == '{')
330 {
331 if chars[i] == '$' {
332 break;
333 }
334 if chars[i] == '*' || chars[i] == '`' {
335 break;
336 }
337 i += 1;
338 }
339 if i == start {
340 i += 1;
341 continue;
342 }
343 out.push(Inline::Text(chars[start..i].iter().collect()));
344 }
345 Ok(out)
346}
347
348fn parse_delimited(
349 chars: &[char],
350 start: usize,
351 marker: &str,
352 line: usize,
353 col: usize,
354) -> Result<(String, usize), ParseError> {
355 let mlen = marker.chars().count();
356 let mut i = start;
357 while i < chars.len() {
358 if chars[i..].iter().collect::<String>().starts_with(marker) {
359 let inner: String = chars[start..i].iter().collect();
360 return Ok((inner, i + mlen));
361 }
362 i += 1;
363 }
364 Err(err(
365 line,
366 col + start,
367 format!("unclosed delimiter '{marker}'"),
368 ))
369}
370
371fn is_valid_param_name(name: &str) -> bool {
372 let mut chars = name.chars();
373 match chars.next() {
374 Some(c) if c.is_ascii_alphabetic() || c == '_' => {}
375 _ => return false,
376 }
377 chars.all(|c| c.is_ascii_alphanumeric() || c == '_')
378}
379
380fn err(line: usize, column: usize, message: impl Into<String>) -> ParseError {
381 ParseError {
382 line,
383 column,
384 message: message.into(),
385 }
386}
387
388#[cfg(test)]
389mod tests {
390 use super::*;
391 use crate::dsl::Inline;
392
393 #[test]
394 fn parses_heading_and_paragraph() {
395 let doc = parse("# Store\nHello **world**").unwrap();
396 assert_eq!(doc.blocks.len(), 2);
397 assert!(matches!(doc.blocks[0], Block::Heading { level: 1, .. }));
398 assert!(matches!(doc.blocks[1], Block::Paragraph { .. }));
399 }
400
401 #[test]
402 fn parses_parameters() {
403 let doc = parse("Order ${OrderId}").unwrap();
404 let Block::Paragraph { inlines, .. } = &doc.blocks[0] else {
405 panic!("expected paragraph");
406 };
407 assert!(matches!(
408 inlines.as_slice(),
409 [
410 Inline::Text(_),
411 Inline::Param(name)
412 ] if name == "OrderId"
413 ));
414 }
415
416 #[test]
417 fn dedupes_collect_is_separate_module() {
418 let doc = parse("@barcode CODE128 ${A}\n@qr ${A}").unwrap();
419 assert_eq!(doc.blocks.len(), 2);
420 }
421
422 #[test]
423 fn strips_comments() {
424 let doc = parse("<!-- hidden -->\nVisible").unwrap();
425 assert_eq!(doc.blocks.len(), 1);
426 }
427
428 #[test]
429 fn rejects_unknown_directive() {
430 assert!(parse("@unknown x").is_err());
431 }
432
433 #[test]
434 fn parses_alignment_prefix() {
435 let doc = parse(":center:\nCentered").unwrap();
436 let Block::Paragraph { align, .. } = &doc.blocks[0] else {
437 panic!();
438 };
439 assert_eq!(*align, Align::Center);
440 }
441}