Export dynvar.ref as Ref with all its fields and methods (#3385)

This is a useful utility to extract references from the tree to build a
DAG. Planning to use this in direct deployment.

Author: denik

libs/dyn/dynvar/ref.go

@@ -15,21 +15,21 @@ var (
 	re         = regexp.MustCompile(fmt.Sprintf(`\$\{(%s(\.%s(\[[0-9]+\])*)*(\[[0-9]+\])*)\}`, baseVarDef, baseVarDef))
 )
 
-// ref represents a variable reference.
+// Ref represents a variable reference.
 // It is a string [dyn.Value] contained in a larger [dyn.Value].
 // Its path within the containing [dyn.Value] is also stored.
-type ref struct {
+type Ref struct {
 	// Original value.
-	value dyn.Value
+	Value dyn.Value
 
 	// String value in the original [dyn.Value].
-	str string
+	Str string
 
 	// Matches of the variable reference in the string.
-	matches [][]string
+	Matches [][]string
 }
 
-// newRef returns a new ref if the given [dyn.Value] contains a string
+// NewRef returns a new Ref if the given [dyn.Value] contains a string
 // with one or more variable references. It returns false if the given
 // [dyn.Value] does not contain variable references.
 //
@@ -38,39 +38,39 @@ type ref struct {
 //   - "${a.b.c}"
 //   - "${a.b[0].c}"
 //   - "${a} ${b} ${c}"
-func newRef(v dyn.Value) (ref, bool) {
+func NewRef(v dyn.Value) (Ref, bool) {
 	s, ok := v.AsString()
 	if !ok {
-		return ref{}, false
+		return Ref{}, false
 	}
 
 	// Check if the string contains any variable references.
 	m := re.FindAllStringSubmatch(s, -1)
 	if len(m) == 0 {
-		return ref{}, false
+		return Ref{}, false
 	}
 
-	return ref{
-		value:   v,
-		str:     s,
-		matches: m,
+	return Ref{
+		Value:   v,
+		Str:     s,
+		Matches: m,
 	}, true
 }
 
-// isPure returns true if the variable reference contains a single
+// IsPure returns true if the variable reference contains a single
 // variable reference and nothing more. We need this so we can
 // interpolate values of non-string types (i.e. it can be substituted).
-func (v ref) isPure() bool {
+func (v Ref) IsPure() bool {
 	// Need single match, equal to the incoming string.
-	if len(v.matches) == 0 || len(v.matches[0]) == 0 {
+	if len(v.Matches) == 0 || len(v.Matches[0]) == 0 {
 		panic("invalid variable reference; expect at least one match")
 	}
-	return v.matches[0][0] == v.str
+	return v.Matches[0][0] == v.Str
 }
 
-func (v ref) references() []string {
+func (v Ref) References() []string {
 	var out []string
-	for _, m := range v.matches {
+	for _, m := range v.Matches {
 		out = append(out, m[1])
 	}
 	return out
@@ -87,16 +87,16 @@ func ContainsVariableReference(s string) bool {
 // If s is a pure variable reference, this function returns the corresponding
 // dyn.Path. Otherwise, it returns false.
 func PureReferenceToPath(s string) (dyn.Path, bool) {
-	ref, ok := newRef(dyn.V(s))
+	ref, ok := NewRef(dyn.V(s))
 	if !ok {
 		return nil, false
 	}
 
-	if !ref.isPure() {
+	if !ref.IsPure() {
 		return nil, false
 	}
 
-	p, err := dyn.NewPathFromString(ref.references()[0])
+	p, err := dyn.NewPathFromString(ref.References()[0])
 	if err != nil {
 		return nil, false
 	}

libs/dyn/dynvar/ref_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func TestNewRefNoString(t *testing.T) {
-	_, ok := newRef(dyn.V(1))
+	_, ok := NewRef(dyn.V(1))
 	require.False(t, ok, "should not match non-string")
 }
 
@@ -23,9 +23,9 @@ func TestNewRefValidPattern(t *testing.T) {
 		"${hello_world.world-_world}": {"hello_world.world-_world"},
 		"${hello_world.world_-world}": {"hello_world.world_-world"},
 	} {
-		ref, ok := newRef(dyn.V(in))
+		ref, ok := NewRef(dyn.V(in))
 		require.True(t, ok, "should match valid pattern: %s", in)
-		assert.Equal(t, refs, ref.references())
+		assert.Equal(t, refs, ref.References())
 	}
 }
 
@@ -42,7 +42,7 @@ func TestNewRefInvalidPattern(t *testing.T) {
 		"${helloworld.9world-world}",    // interpolated second section shouldn't start with number
 	}
 	for _, v := range invalid {
-		_, ok := newRef(dyn.V(v))
+		_, ok := NewRef(dyn.V(v))
 		require.False(t, ok, "should not match invalid pattern: %s", v)
 	}
 }

libs/dyn/dynvar/resolve.go

@@ -46,7 +46,7 @@ type resolver struct {
 	in dyn.Value
 	fn Lookup
 
-	refs     map[string]ref
+	refs     map[string]Ref
 	resolved map[string]dyn.Value
 
 	// Memoization for lookups.
@@ -73,11 +73,11 @@ func (r resolver) run() (out dyn.Value, err error) {
 }
 
 func (r *resolver) collectVariableReferences() (err error) {
-	r.refs = make(map[string]ref)
+	r.refs = make(map[string]Ref)
 
 	// First walk the input to gather all values with a variable reference.
 	_, err = dyn.Walk(r.in, func(p dyn.Path, v dyn.Value) (dyn.Value, error) {
-		ref, ok := newRef(v)
+		ref, ok := NewRef(v)
 		if !ok {
 			// Skip values without variable references.
 			return v, nil
@@ -113,9 +113,9 @@ func (r *resolver) resolveVariableReferences() (err error) {
 	return nil
 }
 
-func (r *resolver) resolveRef(ref ref, seen []string) (dyn.Value, error) {
+func (r *resolver) resolveRef(ref Ref, seen []string) (dyn.Value, error) {
 	// This is an unresolved variable reference.
-	deps := ref.references()
+	deps := ref.References()
 
 	// Resolve each of the dependencies, then interpolate them in the ref.
 	resolved := make([]dyn.Value, len(deps))
@@ -145,19 +145,19 @@ func (r *resolver) resolveRef(ref ref, seen []string) (dyn.Value, error) {
 	}
 
 	// Interpolate the resolved values.
-	if ref.isPure() && complete {
+	if ref.IsPure() && complete {
 		// If the variable reference is pure, we can substitute it.
 		// This is useful for interpolating values of non-string types.
 		//
 		// Note: we use the location of the variable reference to preserve the information
 		// of where it is used. This also means that relative path resolution is done
 		// relative to where a variable is used, not where it is defined.
 		//
-		return dyn.NewValue(resolved[0].Value(), ref.value.Locations()), nil
+		return dyn.NewValue(resolved[0].Value(), ref.Value.Locations()), nil
 	}
 
 	// Not pure; perform string interpolation.
-	for j := range ref.matches {
+	for j := range ref.Matches {
 		// The value is invalid if resolution returned [ErrSkipResolution].
 		// We must skip those and leave the original variable reference in place.
 		if !resolved[j].IsValid() {
@@ -169,14 +169,14 @@ func (r *resolver) resolveRef(ref ref, seen []string) (dyn.Value, error) {
 		if !ok {
 			return dyn.InvalidValue, fmt.Errorf(
 				"cannot interpolate non-string value: %s",
-				ref.matches[j][0],
+				ref.Matches[j][0],
 			)
 		}
 
-		ref.str = strings.Replace(ref.str, ref.matches[j][0], s, 1)
+		ref.Str = strings.Replace(ref.Str, ref.Matches[j][0], s, 1)
 	}
 
-	return dyn.NewValue(ref.str, ref.value.Locations()), nil
+	return dyn.NewValue(ref.Str, ref.Value.Locations()), nil
 }
 
 func (r *resolver) resolveKey(key string, seen []string) (dyn.Value, error) {
@@ -204,7 +204,7 @@ func (r *resolver) resolveKey(key string, seen []string) (dyn.Value, error) {
 	}
 
 	// If the returned value is a valid variable reference, resolve it.
-	ref, ok := newRef(v)
+	ref, ok := NewRef(v)
 	if ok {
 		v, err = r.resolveRef(ref, seen)
 	}