Default value for store_read (#133)

* Default value for store_read

CHANGELOG.md

@@ -6,6 +6,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 ### 🚀 Added
+- Add the `default` arg for `store_read` template function [#133](https://github.com/datanymizer/datanymizer/pull/133)
+  ([@evgeniy-r](https://github.com/evgeniy-r))
 - Add the configurable table order [#127](https://github.com/datanymizer/datanymizer/pull/127)
   ([@evgeniy-r](https://github.com/evgeniy-r))
 - Extend template transformer with shared templates and macros

datanymizer_engine/src/transformers/template/mod.rs

@@ -469,6 +469,14 @@ mod tests {
             serde_yaml::from_str(config).unwrap()
         }
 
+        fn read_default_transformer() -> Transformers {
+            let config = r#"
+                                template:
+                                  format: "Read: {{ store_read(key=_0, default='def key') }}"
+                              "#;
+            serde_yaml::from_str(config).unwrap()
+        }
+
         fn write_transformer() -> Transformers {
             let config = r#"
                   template:
@@ -485,10 +493,12 @@ mod tests {
         #[test]
         fn basic() {
             let mut r = read_transformer();
+            let mut rd = read_default_transformer();
             let mut w = write_transformer();
             let ctx = TransformerInitContext::default();
 
             r.init(&ctx);
+            rd.init(&ctx);
             w.init(&ctx);
 
             let value = w.transform("field", "a", &None).unwrap().unwrap();
@@ -508,15 +518,23 @@ mod tests {
 
             let value = r.transform("field", "key_c", &None).unwrap().unwrap();
             assert_eq!(value, "Read: value_c");
+
+            let value = rd.transform("field", "key_a", &None).unwrap().unwrap();
+            assert_eq!(value, "Read: value_a");
+
+            let value = rd.transform("field", "key_d", &None).unwrap().unwrap();
+            assert_eq!(value, "Read: def key");
         }
 
         #[test]
         fn repeatable_read() {
             let mut r = read_transformer();
+            let mut rd = read_default_transformer();
             let mut w = write_transformer();
             let ctx = TransformerInitContext::default();
 
             r.init(&ctx);
+            rd.init(&ctx);
             w.init(&ctx);
 
             let value = w.transform("field", "a", &None).unwrap().unwrap();
@@ -527,6 +545,39 @@ mod tests {
 
             let value = r.transform("field", "key_a", &None).unwrap().unwrap();
             assert_eq!(value, "Read: value_a");
+
+            let value = rd.transform("field", "key_d", &None).unwrap().unwrap();
+            assert_eq!(value, "Read: def key");
+
+            let value = rd.transform("field", "key_d", &None).unwrap().unwrap();
+            assert_eq!(value, "Read: def key");
+        }
+
+        #[test]
+        fn condition() {
+            let config = r#"
+                                template:
+                                  format: |
+                                    {%- set c = store_read(key=_0, default=false) -%}
+                                    {%- if c -%}
+                                      {{ c }}
+                                    {%- endif -%}
+                              "#;
+            let mut t: Transformers = serde_yaml::from_str(config).unwrap();
+            let mut w = write_transformer();
+            let ctx = TransformerInitContext::default();
+
+            t.init(&ctx);
+            w.init(&ctx);
+
+            let value = w.transform("field", "a", &None).unwrap().unwrap();
+            assert_eq!(value, "Write: value_a into key_a");
+
+            let value = t.transform("field", "key_a", &None).unwrap().unwrap();
+            assert_eq!(value, "value_a");
+
+            let value = t.transform("field", "b", &None).unwrap().unwrap();
+            assert_eq!(value, "");
         }
 
         #[test]

datanymizer_engine/src/transformers/template/store_functions.rs

@@ -18,7 +18,12 @@ fn read<S: KeyValueStore>(store: S) -> impl Function {
                     match store.read_value(&key) {
                         Ok(value) => match value {
                             Some(value) => Ok(value),
-                            None => Err(format!("No such key {}", key).into()),
+                            None => match args.get("default") {
+                                Some(default) => Ok(default.clone()),
+                                None => {
+                                    Err(format!("No such key {} and no default value", key).into())
+                                }
+                            },
                         },
                         Err(e) => Err(e.to_string().into()),
                     }
@@ -101,16 +106,20 @@ mod tests {
         let mut t = Tera::default();
 
         let read_template = "{{ store_read(key='key') }}";
+        let read_default_template = "{{ store_read(key='no_key', default='def') }}";
         let write_template = "{{ store_write(key='key', value='abc') }} \
           {{ store_force_write(key='key2', value='cde') }} \
           {{ store_inc(key='key3', value=1) }}";
 
         register(&mut t, store.clone());
         t.add_raw_template("read", &read_template).unwrap();
+        t.add_raw_template("read_default", &read_default_template)
+            .unwrap();
         t.add_raw_template("write", &write_template).unwrap();
 
         t.render("write", &Context::new()).unwrap();
         assert_eq!(t.render("read", &Context::new()).unwrap(), "abc");
+        assert_eq!(t.render("read_default", &Context::new()).unwrap(), "def");
 
         assert_eq!(store.read_value("key2").unwrap().unwrap(), "cde");
         assert_eq!(store.read_value("key3").unwrap().unwrap(), 1);

docs/transformers.md

@@ -310,8 +310,9 @@ tables:
 
 The full list of functions for working with the store:
 
-* `store_read` - returns a value by a key, raises an error when no such key.<br/>
-  Arguments: `key`.
+* `store_read` - returns a value by key, when no such key returns a default value or raises an error 
+  if no default value is provided.<br/>
+  Arguments: `key`, `default` (the `default` arg is optional).
 
 * `store_write` - stores a value in a key, raises an error when the key is already present.<br/>
   Arguments: `key`, `value`.