tryparse 0.4.4

Multi-strategy parser for messy real-world data. Handles broken JSON, markdown wrappers, and type mismatches.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

//! Intermediate candidate representation for multi-stage parsing.

use crate::value::Source;

/// A candidate substring extracted from the input.
///
/// This represents a potential JSON value before it has been successfully
/// parsed. Candidates can be extracted from prose, code blocks, etc., and
/// then go through fixing and parsing stages.
#[derive(Debug, Clone)]
pub struct Candidate {
    /// The extracted content (potential JSON)
    pub content: String,

    /// How this candidate was extracted
    pub source: CandidateSource,
}

/// Describes how a candidate was extracted from the input.
#[derive(Debug, Clone, PartialEq)]
pub enum CandidateSource {
    /// Direct input (no extraction needed)
    Direct,

    /// Extracted using heuristic brace matching
    Heuristic { pattern: String },

    /// Extracted from markdown code block
    Markdown { language: Option<String> },

    /// Extracted using regex or other pattern
    Pattern { pattern: String },
}

impl Candidate {
    /// Creates a new candidate from direct input
    pub fn direct(content: impl Into<String>) -> Self {
        Self {
            content: content.into(),
            source: CandidateSource::Direct,
        }
    }

    /// Creates a new candidate from heuristic extraction
    pub fn heuristic(content: impl Into<String>, pattern: impl Into<String>) -> Self {
        Self {
            content: content.into(),
            source: CandidateSource::Heuristic {
                pattern: pattern.into(),
            },
        }
    }

    /// Creates a new candidate from markdown extraction
    pub fn markdown(content: impl Into<String>, language: Option<String>) -> Self {
        Self {
            content: content.into(),
            source: CandidateSource::Markdown { language },
        }
    }

    /// Converts this candidate source to a FlexValue source
    pub fn to_source(&self) -> Source {
        match &self.source {
            CandidateSource::Direct => Source::Direct,
            CandidateSource::Heuristic { pattern } => Source::Heuristic {
                pattern: pattern.clone(),
            },
            CandidateSource::Markdown { language } => Source::Markdown {
                lang: language.clone(),
            },
            CandidateSource::Pattern { pattern } => Source::Heuristic {
                pattern: pattern.clone(),
            },
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_direct_candidate() {
        let candidate = Candidate::direct(r#"{"name": "Alice"}"#);
        assert_eq!(candidate.content, r#"{"name": "Alice"}"#);
        assert_eq!(candidate.source, CandidateSource::Direct);
    }

    #[test]
    fn test_heuristic_candidate() {
        let candidate = Candidate::heuristic(r#"{"name": "Alice"}"#, "object");
        assert_eq!(
            candidate.source,
            CandidateSource::Heuristic {
                pattern: "object".to_string()
            }
        );
    }

    #[test]
    fn test_to_source() {
        let candidate = Candidate::heuristic("test", "pattern");
        let source = candidate.to_source();
        assert!(matches!(source, Source::Heuristic { .. }));
    }
}