goat_cli/utils/
variables.rs

1use crate::error::{Error, ErrorKind, Result};
2use crate::utils::{
3    expression::{canonical_field, Variable},
4    field_registry,
5    utils::{did_you_mean, parse_comma_separated},
6};
7use std::collections::BTreeMap;
8
9/// A struct to store the variables
10/// passed in the `-v` flag on the
11/// CLI.
12pub struct Variables<'a> {
13    /// Variables which need to be parsed.
14    variables: &'a str,
15}
16
17impl<'a> Variables<'a> {
18    /// Constructor for [`Variables`].
19    pub fn new(str: &'a str) -> Self {
20        Self { variables: str }
21    }
22
23    /// Parse a single variable. Used in report
24    /// until something more sophisticated is made.
25    pub fn parse_one(
26        &self,
27        reference_data: &BTreeMap<&'static str, Variable<'static>>,
28    ) -> Result<String> {
29        resolve(self.variables.trim(), reference_data)
30    }
31
32    /// Simple parsing of a comma separated string,
33    /// which will error if the variable is not found
34    /// with a suggestion as to which one you meant.
35    ///
36    /// Returns a plain comma-separated field list (no `&fields=` prefix, no percent-encoding).
37    /// The caller is responsible for adding the field as a URL query parameter.
38    pub fn parse(
39        &self,
40        reference_data: &BTreeMap<&'static str, Variable<'static>>,
41        // this is a pretty hacky way of adding this in.
42        taxon_toggle_direct: bool,
43    ) -> Result<String> {
44        let split_vec = parse_comma_separated(self.variables)
45            .iter()
46            .map(|variable| resolve(variable, reference_data))
47            .collect::<Result<Vec<_>>>()?;
48
49        let mut fields: Vec<String> = Vec::new();
50        for el in split_vec {
51            fields.push(el.clone());
52            if taxon_toggle_direct {
53                fields.push(format!("{}:direct", el));
54                fields.push(format!("{}:ancestor", el));
55                fields.push(format!("{}:descendant", el));
56            }
57        }
58
59        Ok(fields.join(","))
60    }
61
62    /// Parse a variable name into key-value pairs for excluding missing and ancestral taxa.
63    ///
64    /// Returns `Vec<(param_name, field_name)>` pairs; the URL builder handles encoding.
65    pub fn parse_exclude(
66        &self,
67        reference_data: &BTreeMap<&'static str, Variable<'static>>,
68    ) -> Result<Vec<(String, String)>> {
69        let split_vec = parse_comma_separated(self.variables)
70            .iter()
71            .map(|variable| resolve(variable, reference_data))
72            .collect::<Result<Vec<_>>>()?;
73
74        let mut pairs = Vec::new();
75        for (exclude_index, field) in split_vec.into_iter().enumerate() {
76            pairs.push((format!("excludeAncestral[{}]", exclude_index), field.clone()));
77            pairs.push((format!("excludeMissing[{}]", exclude_index), field));
78        }
79
80        Ok(pairs)
81    }
82}
83
84/// Resolve a variable name to its canonical form (see
85/// [`canonical_field`]), or error with a suggestion.
86fn resolve(
87    variable: &str,
88    reference_data: &BTreeMap<&'static str, Variable<'static>>,
89) -> Result<String> {
90    if let Some(canonical) = canonical_field(variable, reference_data) {
91        return Ok(canonical.to_string());
92    }
93    // added to GoaT since this binary's variable data was generated
94    if field_registry::is_dynamic_field_any(variable) {
95        return Ok(variable.to_string());
96    }
97    let possibilities = reference_data
98        .keys()
99        .map(|k| k.to_string())
100        .collect::<Vec<String>>();
101    let hint = did_you_mean(&possibilities, variable)
102        .map(|value| format!(" - did you mean \"{}\"?", value))
103        .unwrap_or_default();
104    Err(Error::new(ErrorKind::Variable(format!(
105        "unknown variable \"{}\"{}",
106        variable, hint
107    ))))
108}
109
110#[cfg(test)]
111mod tests {
112    use super::*;
113    use crate::utils::variable_data::GOAT_TAXON_VARIABLE_DATA;
114
115    // ── parse_one ────────────────────────────────────────────────────────────
116
117    #[test]
118    fn test_parse_one_known_variable_returns_name() {
119        let v = Variables::new("genome_size");
120        let result = v.parse_one(&GOAT_TAXON_VARIABLE_DATA).unwrap();
121        assert_eq!(result, "genome_size");
122    }
123
124    #[test]
125    fn test_parse_one_unknown_variable_with_typo_suggests_correction() {
126        // "genome_siz" is close to "genome_size"
127        let v = Variables::new("genome_siz");
128        let err = v.parse_one(&GOAT_TAXON_VARIABLE_DATA).unwrap_err();
129        assert!(
130            err.to_string().contains("genome_size"),
131            "expected suggestion 'genome_size' in: {}",
132            err
133        );
134    }
135
136    // ── parse ────────────────────────────────────────────────────────────────
137
138    #[test]
139    fn test_parse_single_variable_builds_fields_string() {
140        let v = Variables::new("genome_size");
141        let result = v.parse(&GOAT_TAXON_VARIABLE_DATA, false).unwrap();
142        // Returns a plain field list — no &fields= prefix, no percent-encoding
143        assert!(!result.starts_with("&fields="), "should not have &fields= prefix");
144        assert!(result.contains("genome_size"));
145        assert!(!result.ends_with(','), "trailing delimiter present");
146    }
147
148    #[test]
149    fn test_parse_multiple_variables_all_present() {
150        let v = Variables::new("genome_size,c_value");
151        let result = v.parse(&GOAT_TAXON_VARIABLE_DATA, false).unwrap();
152        assert!(result.contains("genome_size"));
153        assert!(result.contains("c_value"));
154        assert!(!result.ends_with(','));
155    }
156
157    #[test]
158    fn test_parse_unknown_variable_returns_err() {
159        let v = Variables::new("not_a_real_var_xyz");
160        assert!(v.parse(&GOAT_TAXON_VARIABLE_DATA, false).is_err());
161    }
162
163    #[test]
164    fn test_parse_toggle_direct_adds_extra_columns() {
165        let v = Variables::new("genome_size");
166        let result = v.parse(&GOAT_TAXON_VARIABLE_DATA, true).unwrap();
167        assert!(result.contains("genome_size:direct"));
168        assert!(result.contains("genome_size:ancestor"));
169        assert!(result.contains("genome_size:descendant"));
170        assert!(!result.ends_with(','));
171    }
172
173    // ── parse_exclude ────────────────────────────────────────────────────────
174
175    #[test]
176    fn test_parse_accepts_synonyms_hyphens_and_case() {
177        let v = Variables::new("ebp_metric_date,Genome-Size");
178        let result = v.parse(&GOAT_TAXON_VARIABLE_DATA, false).unwrap();
179        assert_eq!(result, "ebp_standard_date,genome_size");
180    }
181
182    #[test]
183    fn test_parse_exclude_contains_ancestral_and_missing_segments() {
184        let v = Variables::new("genome_size");
185        let pairs = v.parse_exclude(&GOAT_TAXON_VARIABLE_DATA).unwrap();
186        let keys: Vec<&str> = pairs.iter().map(|(k, _)| k.as_str()).collect();
187        let vals: Vec<&str> = pairs.iter().map(|(_, v)| v.as_str()).collect();
188        assert!(keys.iter().any(|k| k.contains("excludeAncestral")));
189        assert!(keys.iter().any(|k| k.contains("excludeMissing")));
190        assert!(vals.iter().all(|v| *v == "genome_size"));
191    }
192
193    #[test]
194    fn test_parse_exclude_multiple_variables_all_indexed() {
195        let v = Variables::new("genome_size,c_value");
196        let pairs = v.parse_exclude(&GOAT_TAXON_VARIABLE_DATA).unwrap();
197        // Two variables × two param types = 4 pairs
198        assert_eq!(pairs.len(), 4);
199        let keys: Vec<&str> = pairs.iter().map(|(k, _)| k.as_str()).collect();
200        assert!(keys.iter().any(|k| k.contains("[0]")));
201        assert!(keys.iter().any(|k| k.contains("[1]")));
202    }
203}