proteus 0.5.0

Proteus is intended to make dynamic transformation of data using serde serializable, deserialize using JSON and a JSON transformation syntax similar to Javascript JSON syntax. It also supports registering custom Actions to be used in the syntax.
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

use crate::action::Action;
use crate::errors::Error;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::borrow::Cow;
use std::ops::Deref;

/// This type represents an [Action](../action/trait.Action.html) which joins two or more Value's
/// separated by the provided `sep` and returns a Value::String(String).
///
/// This also works with non-string types but they will be converted into a string prior to joining.
#[derive(Debug, Serialize, Deserialize)]
pub struct Join {
    sep: String,
    values: Vec<Box<dyn Action>>,
}

impl Join {
    pub fn new(sep: String, values: Vec<Box<dyn Action>>) -> Self {
        Self { sep, values }
    }
}

#[typetag::serde]
impl Action for Join {
    fn apply<'a>(
        &self,
        source: &'a Value,
        destination: &mut Value,
    ) -> Result<Option<Cow<'a, Value>>, Error> {
        let l = self.values.len() - 1;
        let mut result = String::new();
        for (i, v) in self.values.iter().enumerate() {
            match v.apply(source, destination)? {
                Some(v) => {
                    match v.deref() {
                        Value::String(s) => {
                            if s.is_empty() {
                                continue;
                            }
                            result.push_str(s);
                        }
                        _ => {
                            let s = v.to_string();
                            if s.is_empty() {
                                continue;
                            }
                            result.push_str(&s);
                        }
                    };
                    if i != l {
                        result.push_str(&self.sep);
                    }
                }
                None => continue,
            };
        }

        if result.is_empty() {
            return Ok(None);
        }
        Ok(Some(Cow::Owned(Value::String(result))))
    }
}