Update dis_macro and add ref dis injection

src/haystack/encoding/decode_ref_dis_factory.rs

@@ -0,0 +1,65 @@
+// Copyright (C) 2020 - 2024, J2 Innovations
+
+use std::borrow::Cow;
+use std::sync::RwLock;
+
+/// Enables display values to be injected into encoded/decoded Ref objects.
+///
+/// This is used to handle the case whereby pre-calculated display
+/// names for Refs need to be utilized when encoding/decoding haystack data.
+///
+/// Please note, the return type is a `Cow<str>`. At some point we'll make `Ref` a little
+/// more flexible regarding how it holds its display data.
+type RefDisFactoryFunc<'a> = Box<dyn Fn(&str, Option<&str>) -> Option<Cow<'a, str>> + Send + Sync>;
+
+/// Holds the Ref factory function used for creating Refs.
+static REF_DIS_FACTORY_FUNC: RwLock<Option<RefDisFactoryFunc>> = RwLock::new(None);
+
+/// Get a ref's display name value from any registered factory.
+pub fn get_ref_dis_from_factory<'a>(val: &str, dis: Option<&'a str>) -> Option<Cow<'a, str>> {
+    if let Some(func) = REF_DIS_FACTORY_FUNC.read().unwrap().as_ref() {
+        func(val, dis)
+    } else {
+        dis.map(Cow::Borrowed)
+    }
+}
+
+/// Set the factory function for getting ref display name values.
+pub fn set_ref_dis_factory(factory_fn: Option<RefDisFactoryFunc<'static>>) {
+    *REF_DIS_FACTORY_FUNC.write().unwrap() = factory_fn;
+}
+
+#[cfg(test)]
+mod test {
+    use std::{borrow::Cow, sync::Mutex};
+
+    use super::{get_ref_dis_from_factory, set_ref_dis_factory};
+
+    // Use a mutex to prevent unit tests from interfering with each other. One of the tests
+    // sets some global data so they can overlap.
+    static MUTEX: Mutex<()> = Mutex::new(());
+
+    #[test]
+    fn make_ref_returns_ref() {
+        let _ = MUTEX.lock();
+
+        let dis = get_ref_dis_from_factory("a", Some("c"));
+
+        assert_eq!(dis, Some(Cow::Borrowed("c")));
+    }
+
+    #[test]
+    fn make_ref_from_factory_returns_ref() {
+        let _ = MUTEX.lock();
+
+        let factory_fn = Box::new(|_: &str, _: Option<&str>| Some(Cow::Owned(String::from("c"))));
+
+        set_ref_dis_factory(Some(factory_fn));
+
+        let dis = get_ref_dis_from_factory("a", Some("b"));
+
+        assert_eq!(dis, Some(Cow::Borrowed("c")));
+
+        set_ref_dis_factory(None);
+    }
+}

src/haystack/encoding/json/decode.rs

@@ -3,6 +3,7 @@
 //!
 //! Implement Hayson decoding
 //!
+use crate::encoding::decode_ref_dis_factory::get_ref_dis_from_factory;
 use crate::haystack::val::{
     Column, Coord, Date, DateTime, Dict, Grid, HaystackDict, List, Marker, Na, Number, Ref, Remove,
     Str, Symbol, Time, Uri, Value as HVal, XStr,
@@ -103,7 +104,18 @@ impl<'de> Deserialize<'de> for Ref {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Ref, D::Error> {
         let val = deserializer.deserialize_any(HValVisitor)?;
         match val {
-            HVal::Ref(val) => Ok(val),
+            HVal::Ref(val) => {
+                let dis = get_ref_dis_from_factory(val.value.as_str(), val.dis.as_deref());
+
+                Ok(if dis.as_deref() == val.dis.as_deref() {
+                    val
+                } else {
+                    Ref {
+                        value: val.value,
+                        dis: dis.map(|d| d.into_owned()),
+                    }
+                })
+            }
             _ => Err(D::Error::custom("Invalid Hayson Ref")),
         }
     }
@@ -375,21 +387,17 @@ fn parse_number(dict: &Dict) -> Result<HVal, JsonErr> {
 }
 
 fn parse_ref(dict: &Dict) -> Result<HVal, JsonErr> {
-    match dict.get_str("val") {
-        Some(val) => match dict.get_str("dis") {
-            Some(dis) => Ok(Ref {
+    dict.get_str("val")
+        .map(|val| {
+            let dis_str = dict.get_str("dis").map(|d| d.as_str());
+            let dis = get_ref_dis_from_factory(&val.value, dis_str).map(|val| val.into_owned());
+            Ref {
                 value: val.value.clone(),
-                dis: Some(dis.value.clone()),
+                dis,
             }
-            .into()),
-            None => Ok(Ref {
-                value: val.value.clone(),
-                dis: None,
-            }
-            .into()),
-        },
-        None => Err(JsonErr::custom("Missing or invalid 'val'")),
-    }
+            .into()
+        })
+        .ok_or_else(|| JsonErr::custom("Missing or invalid 'val'"))
 }
 
 fn parse_symbol(dict: &Dict) -> Result<HVal, JsonErr> {

src/haystack/encoding/json/encode.rs

@@ -6,9 +6,12 @@
 
 use chrono::SecondsFormat;
 
-use crate::haystack::val::{
-    Column, Coord, Date, DateTime, Dict, Grid, Marker, Na, Number, Ref, Remove, Symbol, Time, Uri,
-    Value as HVal, XStr,
+use crate::{
+    encoding::decode_ref_dis_factory::get_ref_dis_from_factory,
+    haystack::val::{
+        Column, Coord, Date, DateTime, Dict, Grid, Marker, Na, Number, Ref, Remove, Symbol, Time,
+        Uri, Value as HVal, XStr,
+    },
 };
 
 use serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer};
@@ -54,8 +57,12 @@ impl Serialize for Ref {
         let mut map = serializer.serialize_map(Some(if self.dis.is_none() { 2 } else { 3 }))?;
         map.serialize_entry("_kind", "ref")?;
         map.serialize_entry("val", &self.value)?;
-        if self.dis.is_some() {
-            let dis = self.dis.clone();
+
+        let dis = get_ref_dis_from_factory(self.value.as_str(), self.dis.as_deref())
+            .map(|v| v.into_owned())
+            .or_else(|| self.dis.clone());
+
+        if dis.is_some() {
             map.serialize_entry("dis", &dis)?;
         }
         map.end()

src/haystack/encoding/mod.rs

@@ -7,3 +7,5 @@
 pub mod json;
 #[cfg(feature = "zinc")]
 pub mod zinc;
+
+pub mod decode_ref_dis_factory;

src/haystack/val/dict.rs

@@ -386,7 +386,11 @@ where
 
     if let Some(val) = dict.get("disMacro") {
         return if let Value::Str(val) = val {
-            dis_macro(&val.value, |val| dict.get(val), get_localized)
+            dis_macro(
+                &val.value,
+                |val| dict.get(val).map(Cow::Borrowed),
+                get_localized,
+            )
         } else {
             decode_str_from_value(val)
         };

src/haystack/val/dis_macro.rs

@@ -9,7 +9,7 @@ use regex::{Captures, Regex, Replacer};
 /// values in a display macro string.
 struct DisReplacer<'a, 'b, GetValueFunc, GetLocalizedFunc>
 where
-    GetValueFunc: Fn(&str) -> Option<&'a Value>,
+    GetValueFunc: Fn(&str) -> Option<Cow<'a, Value>>,
     GetLocalizedFunc: Fn(&str) -> Option<Cow<'a, str>>,
 {
     get_value: &'b GetValueFunc,
@@ -20,7 +20,7 @@ where
 impl<'a, 'b, GetValueFunc, GetLocalizedFunc> Replacer
     for DisReplacer<'a, 'b, GetValueFunc, GetLocalizedFunc>
 where
-    GetValueFunc: Fn(&str) -> Option<&'a Value>,
+    GetValueFunc: Fn(&str) -> Option<Cow<'a, Value>>,
     GetLocalizedFunc: Fn(&str) -> Option<Cow<'a, str>>,
 {
     fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) {
@@ -29,9 +29,9 @@ where
         // Replace $tag or ${tag}
         if let Some(cap_match) = caps.get(2).or_else(|| caps.get(4)) {
             if let Some(value) = (self.get_value)(cap_match.as_str()) {
-                if let Value::Ref(val) = value {
+                if let Value::Ref(val) = value.as_ref() {
                     dst.push_str(val.dis.as_ref().unwrap_or(&val.value));
-                } else if let Value::Str(val) = value {
+                } else if let Value::Str(val) = value.as_ref() {
                     dst.push_str(&val.value);
                 } else {
                     dst.push_str(&value.to_string());
@@ -70,7 +70,7 @@ pub fn dis_macro<'a, GetValueFunc, GetLocalizedFunc>(
     get_localized: GetLocalizedFunc,
 ) -> Cow<'a, str>
 where
-    GetValueFunc: Fn(&str) -> Option<&'a Value>,
+    GetValueFunc: Fn(&str) -> Option<Cow<'a, Value>>,
     GetLocalizedFunc: Fn(&str) -> Option<Cow<'a, str>>,
 {
     // Cache the regular expression in memory so it doesn't need to compile on each invocation.
@@ -103,7 +103,7 @@ mod test {
 
     static DICT: OnceLock<Dict> = OnceLock::new();
 
-    fn dict_cb<'a>(name: &str) -> Option<&'a Value> {
+    fn dict_cb<'a>(name: &str) -> Option<Cow<'a, Value>> {
         DICT.get_or_init(|| {
             dict![
                 "equipRef" => Value::make_ref("ref"),
@@ -114,6 +114,7 @@ mod test {
             ]
         })
         .get(name)
+        .map(|val| Cow::Borrowed(val))
     }
 
     fn i18n_cb<'a>(name: &str) -> Option<Cow<'a, str>> {