Merge pull request #1729 from helderco/remove-path-lookup

Remove path based task lookup

plan/task/clientenv.go

@@ -13,19 +13,37 @@ import (
 )
 
 func init() {
-	Register("client.env.*", func() Task { return &clientEnvTask{} })
+	Register("ClientEnv", func() Task { return &clientEnvTask{} })
 }
 
 type clientEnvTask struct {
 }
 
 func (t clientEnvTask) Run(ctx context.Context, pctx *plancontext.Context, _ solver.Solver, v *compiler.Value) (*compiler.Value, error) {
-	lg := log.Ctx(ctx)
+	log.Ctx(ctx).Debug().Msg("loading environment variables")
 
-	envvar := v.ParentLabel(1)
+	fields, err := v.Fields()
+	if err != nil {
+		return nil, err
+	}
 
-	lg.Debug().Str("envvar", envvar).Msg("loading environment variable")
+	envs := make(map[string]interface{})
+	for _, field := range fields {
+		if field.Selector == cue.Str("$dagger") {
+			continue
+		}
+		envvar := field.Label()
+		val, err := t.getEnv(envvar, field.Value, pctx)
+		if err != nil {
+			return nil, err
+		}
+		envs[envvar] = val
+	}
 
+	return compiler.NewValue().FillFields(envs)
+}
+
+func (t clientEnvTask) getEnv(envvar string, v *compiler.Value, pctx *plancontext.Context) (interface{}, error) {
 	env := os.Getenv(envvar)
 	if env == "" {
 		return nil, fmt.Errorf("environment variable %q not set", envvar)
@@ -33,21 +51,20 @@ func (t clientEnvTask) Run(ctx context.Context, pctx *plancontext.Context, _ sol
 
 	// Resolve default in disjunction if a type hasn't been specified
 	val, _ := v.Default()
-	out := compiler.NewValue()
 
 	if plancontext.IsSecretValue(val) {
 		secret := pctx.Secrets.New(env)
-		return out.Fill(secret.MarshalCUE())
+		return secret.MarshalCUE(), nil
 	}
 
 	if val.IsConcrete() {
-		return nil, fmt.Errorf("unexpected concrete value, please use a type")
+		return nil, fmt.Errorf("%s: unexpected concrete value, please use a type", envvar)
 	}
 
 	k := val.IncompleteKind()
 	if k == cue.StringKind {
-		return out.Fill(env)
+		return env, nil
 	}
 
-	return nil, fmt.Errorf("unsupported type %q", k)
+	return nil, fmt.Errorf("%s: unsupported type %q", envvar, k)
 }

plan/task/task.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"strings"
 	"sync"
 
 	"cuelang.org/go/cue"
@@ -21,10 +20,6 @@ var (
 		cue.Str("$dagger"),
 		cue.Str("task"),
 		cue.Hid("_name", pkg.DaggerPackage))
-	lookups = []LookupFunc{
-		defaultLookup,
-		pathLookup,
-	}
 )
 
 // State is the state of the task.
@@ -38,7 +33,6 @@ const (
 )
 
 type NewFunc func() Task
-type LookupFunc func(*compiler.Value) (Task, error)
 
 type Task interface {
 	Run(ctx context.Context, pctx *plancontext.Context, s solver.Solver, v *compiler.Value) (*compiler.Value, error)
@@ -66,26 +60,13 @@ func New(typ string) Task {
 }
 
 func Lookup(v *compiler.Value) (Task, error) {
-	for _, lookup := range lookups {
-		t, err := lookup(v)
-		if err != nil {
-			return nil, err
-		}
-		if t != nil {
-			return t, nil
-		}
-	}
-	return nil, ErrNotTask
-}
-
-func defaultLookup(v *compiler.Value) (Task, error) {
 	if v.Kind() != cue.StructKind {
-		return nil, nil
+		return nil, ErrNotTask
 	}
 
 	typ := v.LookupPath(typePath)
 	if !typ.Exists() {
-		return nil, nil
+		return nil, ErrNotTask
 	}
 
 	typeString, err := typ.String()
@@ -100,46 +81,3 @@ func defaultLookup(v *compiler.Value) (Task, error) {
 
 	return t, nil
 }
-
-func pathLookup(v *compiler.Value) (Task, error) {
-	selectors := v.Path().Selectors()
-
-	// The `actions` field won't have any path based tasks since it's in user land
-	if len(selectors) == 0 || selectors[0].String() == "actions" {
-		return nil, nil
-	}
-
-	// Try an exact match first
-	if t := New(v.Path().String()); t != nil {
-		return t, nil
-	}
-
-	// FIXME: is there a way to avoid having to loop here?
-	var t Task
-	tasks.Range(func(key, value interface{}) bool {
-		if matchPathMask(selectors, key.(string)) {
-			fn := value.(NewFunc)
-			t = fn()
-			return false
-		}
-		return true
-	})
-	return t, nil
-}
-
-func matchPathMask(sels []cue.Selector, mask string) bool {
-	parts := strings.Split(mask, ".")
-	if len(sels) != len(parts) {
-		return false
-	}
-	for i, sel := range sels {
-		// use a '*' in a path mask part to match any selector
-		if parts[i] == "*" {
-			continue
-		}
-		if sel.String() != parts[i] {
-			return false
-		}
-	}
-	return true
-}