BlueGit

timfa posprint

Files

posprint / src / dsl / parser.rs

parser.rs

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