goat_cli/utils/
variables.rs1use 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
9pub struct Variables<'a> {
13 variables: &'a str,
15}
16
17impl<'a> Variables<'a> {
18 pub fn new(str: &'a str) -> Self {
20 Self { variables: str }
21 }
22
23 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 pub fn parse(
39 &self,
40 reference_data: &BTreeMap<&'static str, Variable<'static>>,
41 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 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
84fn 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 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 #[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 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 #[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 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 #[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 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}