feat: parse envars in reference path

operator.go

@@ -197,6 +197,7 @@ func (e *Expr) Resolve(tree map[interface{}]interface{}) (*Expr, error) {
 		return &Expr{Type: Literal, Literal: val}, nil
 
 	case Reference:
+		e.Reference.Nodes = ResolveEnv(e.Reference.Nodes)
 		if _, err := e.Reference.Resolve(tree); err != nil {
 			return nil, ansi.Errorf("@R{Unable to resolve `}@c{%s}@R{`: %s}", e.Reference, err)
 		}
@@ -211,6 +212,18 @@ func (e *Expr) Resolve(tree map[interface{}]interface{}) (*Expr, error) {
 	return nil, ansi.Errorf("@R{unknown expression operand type (}@c{%d}@R{)}", e.Type)
 }
 
+func ResolveEnv(nodes []string) []string {
+    var resolved []string
+    for _, node := range nodes {
+        if len(node) > 0 && node[0] == '$' {
+            resolved = append(resolved, os.Getenv(node[1:]))
+        } else {
+            resolved = append(resolved, node)
+        }
+    }
+    return resolved
+}
+
 // Evaluate ...
 func (e *Expr) Evaluate(tree map[interface{}]interface{}) (interface{}, error) {
 	final, err := e.Resolve(tree)

operator_test.go

@@ -442,6 +442,18 @@ meta:
 			So(r.Value.(string), ShouldEqual, "found it")
 		})
 
+		Convey("can grab a single value using an environment variable in the reference", func() {
+            os.Setenv("SUB_KEY", "subkey")
+            r, err := op.Run(ev, []*Expr{
+                ref("key.$SUB_KEY.value"),
+            })
+            So(err, ShouldBeNil)
+            So(r, ShouldNotBeNil)
+
+            So(r.Type, ShouldEqual, Replace)
+            So(r.Value.(string), ShouldEqual, "found it")
+        })
+
 		Convey("can grab a single list value", func() {
 			r, err := op.Run(ev, []*Expr{
 				ref("key.lonely"),