Very simplistic draft of reference default values

We treat `::` as the delimiter between reference path and default value.

The implementation currently first resolves all nested references in
both the reference and the default value parts before even looking for
`:` and `::`.

Right now, the default value is always emitted as a string. The current
plan is to simply try to parse the default value as JSON to allow
complex default values (directly or via reference). We still need to
decide how exactly we want users to provide literal defaults (possibly
as '${ref:path::`<valid JSON>`}' so that literal booleans etc. work
correctly.

Author: simu

src/refs/mod.rs

@@ -207,7 +207,14 @@ impl Token {
                 }
                 // Construct flattened ref path by resolving any potential nested references in the
                 // Ref's Vec<Token>.
-                let path = interpolate_token_slice(parts, params, state, opts)?;
+                let path_with_default = interpolate_token_slice(parts, params, state, opts)?;
+
+                let (path, default) =
+                    if let Some((path, default)) = path_with_default.split_once("::") {
+                        (path.to_string(), Some(default))
+                    } else {
+                        (path_with_default, None)
+                    };
 
                 if state.seen_paths.contains(&path) {
                     // we've already seen this reference, so we know there's a loop, and can abort
@@ -223,9 +230,17 @@ impl Token {
                 let k0 = refpath_iter.next().unwrap();
                 // v is the value which we update to point to the next value as we recursively
                 // descend into the params Mapping
-                let mut v = params
-                    .get(&k0.into())
-                    .ok_or_else(|| state.render_missing_key_error(&path, k0))?;
+                let v = params.get(&k0.into());
+                let mut v = if v.is_none()
+                    && let Some(dv) = default
+                {
+                    // TODO(sg): parse dv as json
+                    // TODO(sg): make sure we return the default value as a Literal if
+                    // it's a string to avoid incorrect re-resolution.
+                    return Ok(Value::from(dv));
+                } else {
+                    v.ok_or_else(|| state.render_missing_key_error(&path, k0))?
+                };
 
                 // newv is used to hold temporary Values generated by interpolating v
                 let mut newv;
@@ -249,9 +264,17 @@ impl Token {
                         // trivial case: v is a Mapping, we can just lookup the next value based
                         // on `key`.
                         Value::Mapping(_) => {
-                            v = newv
-                                .get(&key.into())
-                                .ok_or_else(|| state.render_missing_key_error(&path, key))?;
+                            let nv = newv.get(&key.into());
+                            v = if nv.is_none()
+                                && let Some(dv) = default
+                            {
+                                // TODO(sg): parse dv as json
+                                // TODO(sg): make sure we return the default value as a Literal if
+                                // it's a string to avoid incorrect re-resolution.
+                                return Ok(Value::from(dv));
+                            } else {
+                                nv.ok_or_else(|| state.render_missing_key_error(&path, key))?
+                            }
                         }
                         // Sequence lookups aren't supported by Python Reclass. We may implement
                         // them in the future.
@@ -267,15 +290,22 @@ impl Token {
                         ),
                         // A lookup into any other Value variant is an error
                         _ => {
-                            return Err(state.render_lookup_error(
-                                &path,
-                                key,
-                                &format!(
-                                    "Can't continue lookup, {} is a {}",
-                                    traversed.join(":"),
-                                    newv.variant()
-                                ),
-                            ));
+                            if let Some(dv) = default {
+                                // TODO(sg): parse dv as json
+                                // TODO(sg): make sure we return the default value as a Literal if
+                                // it's a string to avoid incorrect re-resolution.
+                                return Ok(Value::from(dv));
+                            } else {
+                                return Err(state.render_lookup_error(
+                                    &path,
+                                    key,
+                                    &format!(
+                                        "Can't continue lookup, {} is a {}",
+                                        traversed.join(":"),
+                                        newv.variant()
+                                    ),
+                                ));
+                            }
                         }
                     }
                     // add current segment to list of traversed segments after lookup is completed.