capability_example/
store_failed_snippet.rs

1// ---------------- [ File: capability-example/src/store_failed_snippet.rs ]
2crate::ix!();
3
4pub fn store_failed_snippet(
5    fail_dir: &PathBuf,
6    type_name: &str,
7    snippet_text: &str,
8) -> std::io::Result<PathBuf> {
9    std::fs::create_dir_all(fail_dir)?;
10    let base_name = format!(
11        "{}-parse-failure",
12        type_name
13            .to_lowercase()
14            .replace(' ', "-")
15            .replace('_', "-")
16    );
17    // find next free index
18    let mut index = 0;
19    loop {
20        let candidate = fail_dir.join(format!("{}{}.json", base_name, index));
21        if !candidate.exists() {
22            // write snippet
23            std::fs::write(&candidate, snippet_text)?;
24            return Ok(candidate);
25        }
26        index += 1;
27    }
28}
29
30/// Tries to parse the raw clipboard as type T.  
31/// Returns:
32///   Ok(Some(value)) if parse succeeded,
33///   Ok(None) if it wasn't valid at all for that type (like a total JSON parse fail),
34///   Err(()) if it was valid JSON but fuzzy parse failed => we store it in fail-dir.
35pub fn attempt_snippet_parse<T: FuzzyFromJsonValue>(
36    raw_clipboard: &str,
37    type_name: &str,
38    fail_dir: Option<&PathBuf>,
39) -> Result<Option<T>, ()> {
40    // 1) Attempt raw JSON parse
41    let parsed_json: serde_json::Value = match serde_json::from_str(raw_clipboard) {
42        Ok(val) => val,
43        Err(_e) => {
44            // It's not even valid JSON => definitely not parseable as T => return Ok(None)
45            return Ok(None);
46        }
47    };
48
49    // 2) Attempt fuzzy parse
50    match T::fuzzy_from_json_value(&parsed_json) {
51        Ok(obj) => {
52            // Full success
53            Ok(Some(obj))
54        }
55        Err(ffve) => {
56            // Fuzzy parse error => let's store it if the user gave fail_dir
57            if let Some(dir) = fail_dir {
58                match store_failed_snippet(dir, type_name, raw_clipboard) {
59                    Ok(path) => warn!("Wrote fuzzy-parse failure snippet to {path:?}"),
60                    Err(e) => warn!("Unable to store fuzzy-parse failure snippet: {e}"),
61                }
62            }
63            Err(())
64        }
65    }
66}