neutralts/bif/
parse_bif_each.rs

1#![doc = include_str!("../../doc/bif-each.md")]
2
3use crate::{bif::constants::*, bif::Bif, bif::BifError, constants::*, json, Value};
4
5impl<'a> Bif<'a> {
6    /*
7        {:each; array-name name-for-key name-for-value  >>
8            {:;name-for-key:}={:;name-for-value:}
9        :}
10    */
11    pub(crate) fn parse_bif_each(&mut self) -> Result<(), BifError> {
12        if self.mod_filter || self.mod_negate {
13            return Err(self.bif_error(BIF_ERROR_MODIFIER_NOT_ALLOWED));
14        }
15
16        self.extract_params_code(true);
17
18        if !self.flags.is_empty() {
19            return Err(self.bif_error(BIF_ERROR_FLAGS_NOT_ALLOWED));
20        }
21
22        let mut parts = self.params.split_whitespace();
23
24        let array_name = match parts.next() {
25            Some(value) => value.to_string(),
26            None => {
27                return Err(self.bif_error(BIF_ERROR_ARGUMENTS_NOT_FOUND));
28            }
29        };
30
31        let key_name = match parts.next() {
32            Some(value) => value.to_string(),
33            None => {
34                return Err(self.bif_error(BIF_ERROR_ARGS_KEY_NOT_FOUND));
35            }
36        };
37
38        let val_name = match parts.next() {
39            Some(value) => value.to_string(),
40            None => {
41                return Err(self.bif_error(BIF_ERROR_ARGS_VALUE_NOT_FOUND));
42            }
43        };
44
45        let tmp: String = format!("{}{}", "/", array_name);
46        let mut array = tmp.replace(BIF_ARRAY, "/");
47        let restore_key = self.get_data(&key_name);
48        let restore_val = self.get_data(&val_name);
49
50        let data_storage;
51        if array.starts_with("/local::") {
52            array = array.replace("/local::", "/");
53            data_storage = &self.shared.schema["__indir"][&self.inherit.indir]["data"];
54        } else {
55            data_storage = &self.shared.schema["data"];
56        }
57
58        if let Some(data_value) = data_storage.pointer(&array) {
59            match data_value.to_owned() {
60                Value::Object(obj) => {
61                    for (key, val) in obj.iter() {
62                        self.parse_bif_each_iter(&key_name, &val_name, key, val);
63                    }
64                }
65                Value::Array(arr) => {
66                    for (key, val) in arr.iter().enumerate() {
67                        self.parse_bif_each_iter(&key_name, &val_name, &key.to_string(), val);
68                    }
69                }
70                _ => {}
71            }
72        }
73
74        self.set_data(&key_name, &restore_key);
75        self.set_data(&val_name, &restore_val);
76
77        Ok(())
78    }
79
80    fn parse_bif_each_iter(&mut self, key_name: &str, val_name: &str, key: &String, val: &Value) {
81        self.shared.schema["data"][key_name] = json!(key);
82        self.shared.schema["data"][val_name] = json!(val);
83        self.out += &new_child_parse!(self, &self.code, self.mod_scope);
84    }
85}
86
87#[cfg(test)]
88#[path = "parse_bif_each_tests.rs"]
89mod tests;