BlueGit

timfa posprint

Files

posprint / src / params.rs

params.rs

params.rs 13.7 KiB Download Raw
1use std::collections::BTreeMap;
2
3use crate::dsl::{Document, Inline};
4
5#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6pub enum ParamKind {
7 /// `${Name}` — free text
8 Text,
9 /// `$[Name]` — boolean checkbox
10 Bool,
11}
12
13#[derive(Debug, Clone, PartialEq, Eq)]
14pub struct ParamSpec {
15 pub name: String,
16 pub kind: ParamKind,
17}
18
19pub fn collect_parameters(document: &Document) -> Vec<ParamSpec> {
20 let mut kinds: BTreeMap<String, ParamKind> = BTreeMap::new();
21 for block in &document.blocks {
22 collect_kinds_from_block(block, &mut kinds);
23 }
24 kinds
25 .into_iter()
26 .map(|(name, kind)| ParamSpec { name, kind })
27 .collect()
28}
29
30pub fn collect_parameter_names(document: &Document) -> Vec<String> {
31 collect_parameters(document)
32 .into_iter()
33 .map(|p| p.name)
34 .collect()
35}
36
37pub fn collect_parameter_names_from_source(
38 source: &str,
39) -> Result<Vec<String>, crate::dsl::ParseError> {
40 let doc = crate::dsl::parse(source)?;
41 Ok(collect_parameter_names(&doc))
42}
43
44/// Parse a checkbox-parameter value from CLI / dialog (`true`/`false`, `1`/`0`, …).
45pub fn parse_bool_value(raw: &str) -> Option<bool> {
46 match raw.trim().to_ascii_lowercase().as_str() {
47 "true" | "1" | "yes" | "y" | "on" => Some(true),
48 "false" | "0" | "no" | "n" | "off" | "" => Some(false),
49 _ => None,
50 }
51}
52
53pub fn substitute_inlines(
54 inlines: &[Inline],
55 values: &std::collections::HashMap<String, String>,
56) -> Vec<Inline> {
57 inlines
58 .iter()
59 .map(|inline| match inline {
60 Inline::Text(t) => Inline::Text(t.clone()),
61 Inline::Param(name) => Inline::Text(values.get(name).cloned().unwrap_or_default()),
62 Inline::CheckboxParam(name) => {
63 let checked = values
64 .get(name)
65 .and_then(|v| parse_bool_value(v))
66 .unwrap_or(false);
67 Inline::Checkbox { checked }
68 }
69 Inline::Checkbox { checked } => Inline::Checkbox {
70 checked: *checked,
71 },
72 })
73 .collect()
74}
75
76pub fn substitute_string(input: &str, values: &std::collections::HashMap<String, String>) -> String {
77 substitute_params(input, values, |_| String::new())
78}
79
80/// Substitute `${Name}` using provided values, with sample data for unresolved parameters.
81pub fn substitute_for_preview(
82 input: &str,
83 values: &std::collections::HashMap<String, String>,
84) -> String {
85 substitute_params(input, values, preview_placeholder)
86}
87
88fn substitute_params(
89 input: &str,
90 values: &std::collections::HashMap<String, String>,
91 fallback: impl Fn(&str) -> String,
92) -> String {
93 let mut out = String::new();
94 let chars: Vec<char> = input.chars().collect();
95 let mut i = 0;
96 while i < chars.len() {
97 if chars[i] == '$' && i + 1 < chars.len() && chars[i + 1] == '{' {
98 let start = i + 2;
99 let mut j = start;
100 while j < chars.len() && chars[j] != '}' {
101 j += 1;
102 }
103 if j < chars.len() {
104 let name: String = chars[start..j].iter().collect();
105 let value = values
106 .get(&name)
107 .filter(|v| !v.trim().is_empty())
108 .cloned()
109 .unwrap_or_else(|| fallback(&name));
110 out.push_str(&value);
111 i = j + 1;
112 continue;
113 }
114 }
115 out.push(chars[i]);
116 i += 1;
117 }
118 out
119}
120
121fn preview_placeholder(name: &str) -> String {
122 let lower = name.to_ascii_lowercase();
123 if lower.contains("date") {
124 return "20260115".into();
125 }
126 if lower.contains("total") || lower.contains("amount") || lower.contains("price") {
127 return "99.99".into();
128 }
129 if lower.contains("ean") || lower.contains("upc") || lower.contains("barcode") {
130 return "4006381333931".into();
131 }
132 if lower.contains("url") || lower.contains("link") || lower.contains("qr") {
133 return "https://example.com/sample".into();
134 }
135 if lower.contains("name") || lower.contains("store") {
136 return "Sample Store".into();
137 }
138 "1234567890".into()
139}
140
141/// Sample payload that encodes successfully for preview when user data is not valid.
142pub fn preview_barcode_sample(symbology: crate::dsl::BarcodeSymbology) -> &'static str {
143 use crate::dsl::BarcodeSymbology;
144 match symbology {
145 BarcodeSymbology::Ean13 => "4006381333931",
146 BarcodeSymbology::Ean8 => "96385074",
147 BarcodeSymbology::UpcA => "036000291452",
148 BarcodeSymbology::Itf => "123456",
149 BarcodeSymbology::Codabar => "A40156A",
150 _ => "TEST12345",
151 }
152}
153
154pub fn substitute_document(
155 document: &Document,
156 values: &std::collections::HashMap<String, String>,
157) -> Document {
158 use crate::dsl::Block;
159
160 let blocks = document
161 .blocks
162 .iter()
163 .map(|block| match block {
164 Block::Paragraph { align, inlines } => Block::Paragraph {
165 align: *align,
166 inlines: substitute_inlines(inlines, values),
167 },
168 Block::Heading { level, align, inlines } => Block::Heading {
169 level: *level,
170 align: *align,
171 inlines: substitute_inlines(inlines, values),
172 },
173 Block::List { align, items } => Block::List {
174 align: *align,
175 items: items
176 .iter()
177 .map(|item| substitute_inlines(item, values))
178 .collect(),
179 },
180 Block::Rule => Block::Rule,
181 Block::Feed(n) => Block::Feed(*n),
182 Block::Cut => Block::Cut,
183 Block::Image { path, width, align } => Block::Image {
184 path: substitute_string(path, values),
185 width: *width,
186 align: *align,
187 },
188 Block::Barcode {
189 mode,
190 symbology,
191 data,
192 height,
193 align,
194 show_text,
195 } => Block::Barcode {
196 mode: *mode,
197 symbology: *symbology,
198 data: substitute_string(data, values),
199 height: *height,
200 align: *align,
201 show_text: *show_text,
202 },
203 Block::Qr {
204 mode,
205 data,
206 size,
207 ecc,
208 version,
209 align,
210 } => Block::Qr {
211 mode: *mode,
212 data: substitute_string(data, values),
213 size: *size,
214 ecc: *ecc,
215 version: *version,
216 align: *align,
217 },
218 Block::Date { format, align } => Block::Date {
219 format: format.clone(),
220 align: *align,
221 },
222 Block::Time { format, align } => Block::Time {
223 format: *format,
224 align: *align,
225 },
226 })
227 .collect();
228 Document { blocks }
229}
230
231fn collect_kinds_from_block(
232 block: &crate::dsl::Block,
233 kinds: &mut BTreeMap<String, ParamKind>,
234) {
235 use crate::dsl::Block;
236
237 match block {
238 Block::Paragraph { inlines, .. } | Block::Heading { inlines, .. } => {
239 collect_kinds_from_inlines(inlines, kinds);
240 }
241 Block::List { items, .. } => {
242 for item in items {
243 collect_kinds_from_inlines(item, kinds);
244 }
245 }
246 Block::Image { path, .. } => collect_text_from_raw(path, kinds),
247 Block::Barcode { data, .. } | Block::Qr { data, .. } => collect_text_from_raw(data, kinds),
248 Block::Rule | Block::Feed(_) | Block::Cut | Block::Date { .. } | Block::Time { .. } => {}
249 }
250}
251
252fn collect_kinds_from_inlines(inlines: &[Inline], kinds: &mut BTreeMap<String, ParamKind>) {
253 for inline in inlines {
254 match inline {
255 Inline::Param(name) => {
256 kinds.insert(name.clone(), ParamKind::Text);
257 }
258 Inline::CheckboxParam(name) => {
259 kinds.insert(name.clone(), ParamKind::Bool);
260 }
261 Inline::Text(_) | Inline::Checkbox { .. } => {}
262 }
263 }
264}
265
266fn collect_text_from_raw(text: &str, kinds: &mut BTreeMap<String, ParamKind>) {
267 let chars: Vec<char> = text.chars().collect();
268 let mut i = 0;
269 while i < chars.len() {
270 if chars[i] == '$' && i + 1 < chars.len() && chars[i + 1] == '{' {
271 let start = i + 2;
272 let mut j = start;
273 while j < chars.len() && chars[j] != '}' {
274 j += 1;
275 }
276 if j < chars.len() {
277 let name: String = chars[start..j].iter().collect();
278 kinds.insert(name, ParamKind::Text);
279 i = j + 1;
280 continue;
281 }
282 }
283 i += 1;
284 }
285}
286
287pub fn substitute_inlines_for_preview(
288 inlines: &[Inline],
289 values: &std::collections::HashMap<String, String>,
290) -> String {
291 let mut out = String::new();
292 for inline in inlines {
293 match inline {
294 Inline::Text(t) => out.push_str(t),
295 Inline::Param(name) => {
296 out.push_str(&substitute_for_preview(&format!("${{{name}}}"), values));
297 }
298 Inline::CheckboxParam(name) => {
299 let checked = values
300 .get(name)
301 .and_then(|v| parse_bool_value(v))
302 .unwrap_or(false);
303 out.push_str(crate::dsl::checkbox_glyph(checked));
304 }
305 Inline::Checkbox { checked } => {
306 out.push_str(crate::dsl::checkbox_glyph(*checked));
307 }
308 }
309 }
310 out
311}
312
313/// Validate that bool parameters have parseable values when present.
314pub fn invalid_bool_parameters(
315 document: &Document,
316 values: &std::collections::HashMap<String, String>,
317) -> Vec<String> {
318 collect_parameters(document)
319 .into_iter()
320 .filter(|p| p.kind == ParamKind::Bool)
321 .filter_map(|p| {
322 let Some(raw) = values.get(&p.name) else {
323 return None;
324 };
325 if parse_bool_value(raw).is_some() {
326 None
327 } else {
328 Some(p.name)
329 }
330 })
331 .collect()
332}
333
334#[cfg(test)]
335mod tests {
336 use super::*;
337 use std::collections::HashMap;
338
339 #[test]
340 fn collects_unique_sorted_names() {
341 let doc = crate::dsl::parse("${B}\n${A}\n${B}").unwrap();
342 assert_eq!(collect_parameter_names(&doc), vec!["A", "B"]);
343 }
344
345 #[test]
346 fn collects_checkbox_params_as_bool() {
347 let doc = crate::dsl::parse("$[Paid]\n${Name}").unwrap();
348 let params = collect_parameters(&doc);
349 assert_eq!(
350 params,
351 vec![
352 ParamSpec {
353 name: "Name".into(),
354 kind: ParamKind::Text,
355 },
356 ParamSpec {
357 name: "Paid".into(),
358 kind: ParamKind::Bool,
359 },
360 ]
361 );
362 }
363
364 #[test]
365 fn preview_substitutes_inlines() {
366 let doc = crate::dsl::parse("Hello ${Name}").unwrap();
367 let crate::dsl::Block::Paragraph { inlines, .. } = &doc.blocks[0] else {
368 panic!();
369 };
370 let mut values = HashMap::new();
371 values.insert("Name".into(), "Ada".into());
372 assert_eq!(
373 substitute_inlines_for_preview(inlines, &values),
374 "Hello Ada"
375 );
376 }
377
378 #[test]
379 fn substitutes_checkbox_param_to_glyph() {
380 let doc = crate::dsl::parse("$[Paid] done").unwrap();
381 let mut values = HashMap::new();
382 values.insert("Paid".into(), "true".into());
383 let sub = substitute_document(&doc, &values);
384 let crate::dsl::Block::Paragraph { inlines, .. } = &sub.blocks[0] else {
385 panic!();
386 };
387 assert!(matches!(
388 &inlines[0],
389 Inline::Checkbox { checked: true }
390 ));
391 assert_eq!(
392 substitute_inlines_for_preview(
393 &[Inline::CheckboxParam("Paid".into())],
394 &values
395 ),
396 "[\u{221A}]"
397 );
398 }
399
400 #[test]
401 fn preview_substitutes_placeholders_for_barcodes() {
402 let text = substitute_for_preview("${DocumentNumber}", &HashMap::new());
403 assert_eq!(text, "1234567890");
404 }
405
406 #[test]
407 fn substitutes_all_occurrences() {
408 let doc = crate::dsl::parse("Hi ${Name} and ${Name}").unwrap();
409 let mut values = HashMap::new();
410 values.insert("Name".into(), "Ada".into());
411 let sub = substitute_document(&doc, &values);
412 let crate::dsl::Block::Paragraph { inlines, .. } = &sub.blocks[0] else {
413 panic!();
414 };
415 assert!(matches!(
416 inlines.as_slice(),
417 [
418 Inline::Text(a),
419 Inline::Text(b),
420 Inline::Text(c),
421 Inline::Text(d),
422 ] if a == "Hi " && b == "Ada" && c == " and " && d == "Ada"
423 ));
424 }
425
426 #[test]
427 fn parse_bool_value_accepts_common_forms() {
428 assert_eq!(parse_bool_value("true"), Some(true));
429 assert_eq!(parse_bool_value("FALSE"), Some(false));
430 assert_eq!(parse_bool_value("1"), Some(true));
431 assert_eq!(parse_bool_value("0"), Some(false));
432 assert_eq!(parse_bool_value("maybe"), None);
433 }
434}