Implement filter helper and use it to suppress reactive variables for non-widget fields

src/templates/helpers.rs

@@ -6,9 +6,11 @@ use serde_json::Value;
 
 pub mod merge;
 pub mod uniq_lines;
+pub mod filter;
 
 use merge::register_merge;
 use uniq_lines::register_uniq_lines;
+use filter::register_filter;
 
 pub fn register_helpers<'a>(h: Handlebars<'a>) -> Handlebars<'a> {
     let h = register_concat_helper(h);
@@ -19,6 +21,7 @@ pub fn register_helpers<'a>(h: Handlebars<'a>) -> Handlebars<'a> {
     let h = register_pluralize_helpers(h);
     let h = register_merge(h);
     let h = register_uniq_lines(h);
+    let h = register_filter(h);
 
     h
 }

src/templates/helpers/filter.rs

@@ -0,0 +1,157 @@
+use handlebars::{
+    Context, Handlebars, Helper, HelperDef, RenderContext, RenderError,
+    ScopedJson,
+};
+use serde_json::{json, Value, Map};
+
+#[derive(Clone, Copy)]
+pub struct FilterHelper;
+
+/// A Handlebars helper to filter an iterable JSON value.
+/// It receives the value to be filtered and a string containing the condition predicate,
+/// then uses Handlebars' truthy logic to filter the items in the value.
+/// It also supports the `#if` helper's `includeZero` optional parameter.
+impl HelperDef for FilterHelper {
+    fn call_inner<'reg: 'rc, 'rc>(
+        &self,
+        h: &Helper<'reg, 'rc>,
+        r: &'reg Handlebars<'reg>,
+        _ctx: &'rc Context,
+        _rc: &mut RenderContext<'reg, 'rc>,
+    ) -> Result<ScopedJson<'reg, 'rc>, RenderError> {
+        let mut params = h.params().iter();
+        let value = params
+            .next()
+            .ok_or(RenderError::new(
+                "Filter helper: Param not found for index 0; must be value to be filtered",
+            ))?
+            .value();
+
+        let condition = params
+            .next()
+            .ok_or(RenderError::new("Filter helper: Param not found for index 1; must be string containing filter condition predicate"))?
+            .value()
+            .as_str()
+            .ok_or(RenderError::new("Filter helper: filter condition predicate must be a string"))?;
+
+        let include_zero = h
+            .hash_get("includeZero")
+            .and_then(|v| v.value().as_bool())
+            .unwrap_or(false);
+
+        // This template allows us to evaluate the condition according to
+        // Handlebars' available context/property logic, helper functions, and
+        // truthiness logic.
+        let template = format!(
+            "{}{}{}{}",
+            "{{#if ",
+            condition,
+            include_zero.then_some(" includeZero=true").unwrap_or(""),
+            "}}true{{else}}false{{/if}}"
+        );
+
+        match value {
+            Value::Array(items) => {
+                let mut filtered_array = vec![];
+                for item in items.iter() {
+                    match r.render_template(&template, &item) {
+                        Ok(s) => {
+                            if s.as_str() == "true" {
+                                filtered_array.push(item);
+                            }
+                        },
+                        Err(e) => {
+                            return Err(e);
+                        }
+                    }
+                }
+                Ok(ScopedJson::Derived(json!(filtered_array)))
+            },
+            Value::Object(object) => {
+                let mut filtered_object = Map::new();
+                for key in object.clone().keys() {
+                    if let Some(v) = object.get(key) {
+                        match r.render_template(&template, &v) {
+                            Ok(s) => {
+                                if s.as_str() == "true" {
+                                    filtered_object.insert(key.into(), v.clone());
+                                }
+                            },
+                            Err(e) => {
+                                return Err(e);
+                            }
+                        }
+                    }
+                }
+                Ok(ScopedJson::Derived(json!(filtered_object)))
+            },
+            _ => Err(RenderError::new("Filter helper: value to be filtered must be an array or object"))
+        }
+    }
+}
+
+pub fn register_filter<'a>(mut h: Handlebars<'a>) -> Handlebars<'a> {
+    h.register_helper("filter", Box::new(FilterHelper));
+
+    h
+}
+
+#[cfg(test)]
+mod tests {
+    use handlebars::Handlebars;
+    use serde_json::json;
+    use crate::templates::helpers::register_filter;
+
+    fn setup_handlebars<'a>() -> Handlebars<'a> {
+        let hbs = Handlebars::new();
+        let hbs = register_filter(hbs);
+        hbs
+    }
+
+    #[test]
+    fn respects_include_zero() {
+        let hbs = setup_handlebars();
+        let value = json!([0, 1, 0, 2, 0, 3, 0, 4, 0, 5]);
+        // The predicate filters out zeroes.
+        let template = "{{#each (filter this \"this\")}}{{this}}{{/each}}";
+        match hbs.render_template(&template, &value) {
+            Ok(s) => assert_eq!(s, "12345", "`filter` helper did not filter out falsy zero"),
+            Err(e) => panic!("{}", e)
+        }
+        // This predicate, however, does not.
+        let template = "{{#each (filter this \"this\" includeZero=true)}}{{this}}{{/each}}";
+        match hbs.render_template(&template, &value) {
+            Ok(s) => assert_eq!(s, "0102030405", "`filter` helper did not treat zero as truthy"),
+            Err(e) => panic!("{}", e)
+        }
+    }
+
+    #[test]
+    fn can_filter_object_by_value() {
+        let hbs = setup_handlebars();
+        let value = json!({"name": "Alice", "age": 24, "wild": false, "species": "iguana"});
+        // The predicate filters out the 'wild' property.
+        let template = "{{#each (filter this \"this\")}}{{@key}}: {{this}}, {{/each}}";
+        match hbs.render_template(&template, &value) {
+            Ok(s) => assert_eq!(s, "name: Alice, age: 24, species: iguana, ", "`filter` helper did not filter object key/value pairs by value"),
+            Err(e) => panic!("{}", e)
+        }
+    }
+
+
+    #[test]
+    fn can_filter_complex_value() {
+        let hbs = setup_handlebars();
+        let value = json!([
+            {"name": "Alice", "age": 24, "wild": true, "species": "iguana"},
+            {"name": "Bob", "age": 3, "wild": false, "species": "hamster"},
+            {"name": "Carol", "age": 1, "wild": true, "species": "octopus"}
+        ]);
+        // The predicate filters out domestic animals.
+        let template = "{{#each (filter this \"wild\")}}{{name}} the {{species}} is {{age}}. {{/each}}";
+        match hbs.render_template(&template, &value) {
+            Ok(s) => assert_eq!(s, "Alice the iguana is 24. Carol the octopus is 1. ", "`filter` helper did not operate on a list full of complex values"),
+            Err(e) => panic!("{}", e)
+        }
+    }
+}

templates/svelte/entry-type/ui/src/{{dna_role_name}}/{{coordinator_zome_manifest.name}}/{{#if crud.update}}Edit{{pascal_case entry_type.name}}.svelte{{¡if}}.hbs

@@ -39,7 +39,7 @@ let {{camel_case field_name}}: Array<{{> (concat field_type.type "/type")}} | un
 
 let errorSnackbar: Snackbar;
 
-$: {{#each entry_type.fields}}{{#if widget}}{{camel_case field_name}}{{#unless @last}}, {{/unless}}{{/if}}{{/each}};
+$: {{#each (filter entry_type.fields "widget")}}{{camel_case field_name}}{{#unless @last}}, {{/unless}}{{/each}};
 $: is{{pascal_case entry_type.name}}Valid = true{{#each entry_type.fields}}{{#if widget}}{{#if (eq cardinality "single")}} && {{> (concat field_type.type "/" widget "/is-valid") variable_to_validate=(camel_case field_name) }}{{/if}}{{#if (eq cardinality "vector")}} && {{camel_case field_name}}.every(e => {{> (concat field_type.type "/" widget "/is-valid") variable_to_validate="e" }}){{/if}}{{/if}}{{/each}};
 
 onMount(() => {
@@ -55,7 +55,7 @@ onMount(() => {
 
 async function update{{pascal_case entry_type.name}}() {
 
-  const {{camel_case entry_type.name}}: {{pascal_case entry_type.name}} = { 
+  const {{camel_case entry_type.name}}: {{pascal_case entry_type.name}} = {
   {{#each entry_type.fields}}
     {{#if widget}}
       {{#if (eq cardinality "single") }}
@@ -86,7 +86,7 @@ async function update{{pascal_case entry_type.name}}() {
         updated_{{snake_case entry_type.name}}: {{camel_case entry_type.name}}
       }
     });
-  
+
     dispatch('{{kebab_case entry_type.name}}-updated', { actionHash: updateRecord.signed_action.hashed.hash });
   } catch (e) {
     errorSnackbar.labelText = `Error updating the {{lower_case entry_type.name}}: ${e.data.data}`;
@@ -99,7 +99,7 @@ async function update{{pascal_case entry_type.name}}() {
 </mwc-snackbar>
 <div style="display: flex; flex-direction: column">
   <span style="font-size: 18px">Edit {{pascal_case entry_type.name}}</span>
-  
+
 {{#each entry_type.fields}}
   {{#if widget}}
   <div style="margin-bottom: 16px">
@@ -108,7 +108,7 @@ async function update{{pascal_case entry_type.name}}() {
     {{else}}
     {{> Vec/edit/render field_name=field_name field_type=field_type widget=widget }}
     {{/if}}
-    
+
   </div>
 
   {{/if}}
@@ -121,7 +121,7 @@ async function update{{pascal_case entry_type.name}}() {
       on:click={() => dispatch('edit-canceled')}
       style="flex: 1; margin-right: 16px"
     ></mwc-button>
-    <mwc-button 
+    <mwc-button
       raised
       label="Save"
       disabled={!is{{pascal_case entry_type.name}}Valid}