polydat 0.2.0

Polydat — a variates construction engine
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

// Copyright 2024-2026 Jonathan Shook
// SPDX-License-Identifier: Apache-2.0

//! [`parse_text`] — entry point for text-block consumers.
//!
//! Accepts a single string holding either YAML or JSON, picks
//! the right parser, deserializes into a
//! [`ComprehensionSpec`], and routes through
//! [`ComprehensionSpec::into_algebra`].
//!
//! Detection rule: a leading `{` (after trimming whitespace)
//! is JSON; anything else is YAML.  YAML is a strict superset
//! of JSON for the shapes we accept, so YAML can read JSON
//! input fine — but choosing the matching parser surfaces
//! sharper error messages for JSON authors.

use super::serde_form::{ComprehensionSpec, SpecConvertError};
use crate::iteration::comprehension::ast::Comprehension as AlgebraAst;

/// Parse a YAML or JSON text block describing a comprehension
/// into the algebra-layer AST.
///
/// Detection is leading-character based: `{...}` ⇒ JSON,
/// otherwise YAML.
pub fn parse_text(text: &str) -> Result<AlgebraAst, TextParseError> {
    let spec = deserialize_spec(text)?;
    let algebra = spec
        .into_algebra()
        .map_err(TextParseError::Convert)?;
    Ok(algebra)
}

fn deserialize_spec(text: &str) -> Result<ComprehensionSpec, TextParseError> {
    let trimmed = text.trim_start();
    if trimmed.starts_with('{') {
        serde_json::from_str(text).map_err(|e| TextParseError::Json(e.to_string()))
    } else {
        serde_yaml::from_str(text).map_err(|e| TextParseError::Yaml(e.to_string()))
    }
}

/// Errors produced by [`parse_text`].
#[derive(Debug, Clone)]
pub enum TextParseError {
    /// YAML deserialization failed.
    Yaml(String),
    /// JSON deserialization failed.
    Json(String),
    /// The deserialized [`ComprehensionSpec`] failed to
    /// convert into the algebra AST.
    Convert(SpecConvertError),
}

impl std::fmt::Display for TextParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            TextParseError::Yaml(msg) => write!(f, "YAML parse error: {msg}"),
            TextParseError::Json(msg) => write!(f, "JSON parse error: {msg}"),
            TextParseError::Convert(e) => write!(f, "spec conversion error: {e}"),
        }
    }
}

impl std::error::Error for TextParseError {}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::iteration::comprehension::strategy::StrategyName;

    #[test]
    fn yaml_text_block() {
        let text = r#"
            for: "k in 1..10, limit in [10, 100]"
            where: "{k} > 0"
            order: "halton/20"
        "#;
        let algebra = parse_text(text).unwrap();
        match algebra {
            AlgebraAst::Order {
                strategy: StrategyName::Halton,
                truncation: Some(20),
                ..
            } => {}
            other => panic!("expected Order(Halton, Some(20)), got {other:?}"),
        }
    }

    #[test]
    fn json_text_block() {
        let text = r#"
            {
                "for": "k in 1..10",
                "order": "lex/5"
            }
        "#;
        let algebra = parse_text(text).unwrap();
        match algebra {
            AlgebraAst::Order {
                strategy: StrategyName::Lex,
                truncation: Some(5),
                ..
            } => {}
            other => panic!("expected Order(Lex, Some(5)), got {other:?}"),
        }
    }

    #[test]
    fn json_union_form() {
        let text = r#"{
            "for": [
                ["k in 10",  "limit in [1, 2, 3]"],
                ["k in 100", "limit in [10, 20, 30]"]
            ]
        }"#;
        let algebra = parse_text(text).unwrap();
        match algebra {
            AlgebraAst::Union { children } => assert_eq!(children.len(), 2),
            other => panic!("expected Union, got {other:?}"),
        }
    }

    #[test]
    fn malformed_yaml_surfaces_error() {
        let text = r#"
            for: [unterminated
        "#;
        let err = parse_text(text).unwrap_err();
        assert!(matches!(err, TextParseError::Yaml(_)));
    }

    #[test]
    fn malformed_json_surfaces_error() {
        let text = r#"{ "for": "k in 1..10", oops }"#;
        let err = parse_text(text).unwrap_err();
        assert!(matches!(err, TextParseError::Json(_)));
    }

    #[test]
    fn convert_error_surfaces() {
        let text = r#"
            for: "k in 1..10"
            order: "garbage(((not valid"
        "#;
        let err = parse_text(text).unwrap_err();
        assert!(matches!(err, TextParseError::Convert(_)));
    }
}