#transformation #transform #json

bumblebee

Bumblebee is a JSON transformer with simple built in rules that can easily be implemented by even the average user. It is designed to be extensible, simple to use and serializable for easy storage and creation within service and apps.

2 releases

0.1.1 Jun 23, 2019
0.1.0 Jun 22, 2019

#81 in #transformation

MIT/Apache

70KB
2K SLoC

Serde JSON   Build Status Latest Version

Bumblebee is a JSON transformer with simple built in rules that can easily be implemented by even the average user. It is designed to be extensible, simple to use and serializable for easy storage and creation within service and apps.


[dependencies]
bumblebee = "0.1"

Example usages

use bumblebee::prelude::*;
use bumblebee::errors::Result;
fn test_example() -> Result<()> {
      let trans = TransformerBuilder::default()
        .add_direct("user_id", "id")?
        .add_direct("full-name", "name")?
        .add_flatten(
               "nicknames",
               "",
               FlattenOps {
                   recursive: true,
                   prefix: Some("nickname"),
                   separator: Some("_"),
                   manipulation: None,
               },
           )?
        .add_direct("nested.inner.key", "prev_nested")?
        .add_direct("nested.my_arr[1]", "prev_arr")?
        .build()?;
    let input = r#"
        {
            "user_id":"111",
            "full-name":"Dean Karn",
            "nicknames":["Deano","Joey Bloggs"],
            "nested": {
                "inner":{
                    "key":"value"
                },
                "my_arr":[null,"arr_value",null]
            }
        }"#;
    let expected = r#"{"id":"111","name":"Dean Karn","nickname_1":"Deano","nickname_2":"Joey Bloggs","prev_arr":"arr_value","prev_nested":"value"}"#;
    let res = trans.apply_from_str(input)?;
    assert_eq!(expected, serde_json::to_string(&res)?);
    Ok(())
}

or when you want to do struct to struct transformations

use bumblebee::prelude::*;
use bumblebee::errors::Result;
use serde::{Serialize, Deserialize};
fn test_struct() -> Result<()> {
    #[derive(Debug, Serialize)]
    struct From {
        existing: String,
    }
    #[derive(Debug, Deserialize, PartialEq)]
    struct To {
        new: String,
    }
    let trans = TransformerBuilder::default()
        .add_direct("existing", "new")?
        .build()?;
    let from = From {
        existing: String::from("existing_value"),
    };
    let expected = To {
        new: String::from("existing_value"),
    };
    let res: To = trans.apply_to(from)?;
    assert_eq!(expected, res);
    Ok(())
}

License

Licensed under either of Apache License, Version 2.0 or MIT license at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Serde by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

Dependencies

~1.8–2.4MB
~56K SLoC