variables.go

package task

import (
	"fmt"
	"maps"
	"os"
	"path/filepath"
	"strings"

	"github.com/joho/godotenv"

	"github.com/wallix/task/v3/errors"
	"github.com/wallix/task/v3/internal/deepcopy"
	"github.com/wallix/task/v3/internal/env"
	"github.com/wallix/task/v3/internal/execext"
	"github.com/wallix/task/v3/internal/filepathext"
	"github.com/wallix/task/v3/internal/fingerprint"
	"github.com/wallix/task/v3/internal/templater"
	"github.com/wallix/task/v3/taskfile/ast"
)

// CompiledTask returns a copy of a task, but replacing variables in almost all
// properties using the Go template package.
func (e *Executor) CompiledTask(call *Call) (*ast.Task, error) {
	return e.compiledTask(call, true)
}

// FastCompiledTask is like CompiledTask, but it skippes dynamic variables.
func (e *Executor) FastCompiledTask(call *Call) (*ast.Task, error) {
	return e.compiledTask(call, false)
}

func (e *Executor) CompiledTaskForTaskList(call *Call) (*ast.Task, error) {
	origTask, err := e.GetTask(call)
	if err != nil {
		return nil, err
	}

	vars, err := e.Compiler.FastGetVariables(origTask, call)
	if err != nil {
		return nil, err
	}

	cache := &templater.Cache{Vars: vars}

	return &ast.Task{
		Task:                 origTask.Task,
		Label:                templater.Replace(origTask.Label, cache),
		Desc:                 templater.Replace(origTask.Desc, cache),
		Prompt:               templater.Replace(origTask.Prompt, cache),
		Summary:              templater.Replace(origTask.Summary, cache),
		Aliases:              origTask.Aliases,
		Sources:              origTask.Sources,
		Generates:            origTask.Generates,
		Dirs:                 origTask.Dirs,
		Set:                  origTask.Set,
		Shopt:                origTask.Shopt,
		Vars:                 vars,
		Env:                  nil,
		Dotenv:               origTask.Dotenv,
		Silent:               deepcopy.Scalar(origTask.Silent),
		Interactive:          origTask.Interactive,
		Internal:             origTask.Internal,
		Prefix:               origTask.Prefix,
		IgnoreError:          origTask.IgnoreError,
		Run:                  origTask.Run,
		IncludeVars:          origTask.IncludeVars,
		IncludedTaskfileVars: origTask.IncludedTaskfileVars,
		Platforms:            origTask.Platforms,
		Location:             origTask.Location,
		Requires:             origTask.Requires,
		Watch:                origTask.Watch,
		Namespace:            origTask.Namespace,
		Failfast:             origTask.Failfast,
	}, nil
}

func (e *Executor) compiledTask(call *Call, evaluateShVars bool) (*ast.Task, error) {
	origTask, err := e.GetTask(call)
	if err != nil {
		return nil, err
	}

	var vars *ast.Vars
	if evaluateShVars {
		vars, err = e.Compiler.GetVariables(origTask, call)
	} else {
		vars, err = e.Compiler.FastGetVariables(origTask, call)
	}
	if err != nil {
		return nil, err
	}
	fullName := origTask.Task
	if matches, exists := vars.Get("MATCH"); exists {
		for _, match := range matches.Value.([]string) {
			fullName = strings.Replace(fullName, "*", match, 1)
		}
	}

	cache := &templater.Cache{Vars: vars}
	new := ast.Task{
		Task:                 origTask.Task,
		Label:                templater.Replace(origTask.Label, cache),
		Desc:                 templater.Replace(origTask.Desc, cache),
		Prompt:               templater.Replace(origTask.Prompt, cache),
		Summary:              templater.Replace(origTask.Summary, cache),
		Aliases:              origTask.Aliases,
		Sources:              templater.ReplaceGlobs(origTask.Sources, cache),
		Generates:            templater.ReplaceGlobs(origTask.Generates, cache),
		Dirs:                 templater.Replace(origTask.Dirs, cache),
		Set:                  origTask.Set,
		Shopt:                origTask.Shopt,
		Vars:                 vars,
		Env:                  nil,
		Dotenv:               templater.Replace(origTask.Dotenv, cache),
		Silent:               deepcopy.Scalar(origTask.Silent),
		Interactive:          origTask.Interactive,
		Internal:             origTask.Internal,
		Prefix:               templater.Replace(origTask.Prefix, cache),
		IgnoreError:          origTask.IgnoreError,
		Run:                  templater.Replace(origTask.Run, cache),
		IncludeVars:          origTask.IncludeVars,
		IncludedTaskfileVars: origTask.IncludedTaskfileVars,
		RawCmds:              origTask.Cmds,
		Cache:                nil, // resolved below after CHECKSUM is available
		Platforms:            origTask.Platforms,
		If:                   templater.Replace(origTask.If, cache),
		Location:             origTask.Location,
		Requires:             origTask.Requires,
		Watch:                origTask.Watch,
		Failfast:             origTask.Failfast,
		Namespace:            origTask.Namespace,
		FullName:             fullName,
	}
	for i := range new.Dirs {
		new.Dirs[i], err = execext.ExpandLiteral(new.Dirs[i])
		if err != nil {
			return nil, err
		}
	}
	if e.Dir != "" {
		new.Dirs = append([]string{e.Dir}, new.Dirs...)
	}
	if new.Prefix == "" {
		new.Prefix = new.Task
	}

	dotenvEnvs := ast.NewVars()
	if len(new.Dotenv) > 0 {
		for _, dotEnvPath := range new.Dotenv {
			dotEnvPath = filepathext.JoinDirs(append(new.Dirs, dotEnvPath))
			if _, err := os.Stat(dotEnvPath); os.IsNotExist(err) {
				continue
			}
			envs, err := godotenv.Read(dotEnvPath)
			if err != nil {
				return nil, err
			}
			for key, value := range envs {
				if _, ok := dotenvEnvs.Get(key); !ok {
					dotenvEnvs.Set(key, ast.Var{Value: value})
				}
			}
		}
	}

	new.Env = ast.NewVars()
	new.Env.Merge(templater.ReplaceVars(e.Taskfile.Env, cache), nil)
	new.Env.Merge(templater.ReplaceVars(dotenvEnvs, cache), nil)
	new.Env.Merge(templater.ReplaceVars(origTask.Env, cache), nil)
	if evaluateShVars {
		for k, v := range new.Env.All() {
			// If the variable is not dynamic, we can set it and return
			if v.Value != nil || v.Sh == nil {
				new.Env.Set(k, ast.Var{Value: v.Value})
				continue
			}
			static, err := e.Compiler.HandleDynamicVar(v, new.ComputeDir(), env.GetFromVars(new.Env))
			if err != nil {
				return nil, err
			}
			new.Env.Set(k, ast.Var{Value: static})
		}
	}

	// Compute source hash from RawCmds (unresolved templates) for stable
	// checksumming. CHECKSUM must be available before cmd/cache resolution.
	if len(origTask.Sources) > 0 {
		checker := fingerprint.NewChecksumChecker(e.TempDir.Fingerprint, &new)
		new.SourceHash = checker.SourceValue()
		vars.Set("CHECKSUM", ast.Var{Live: new.SourceHash})
		cache.ResetCache()
	}

	if len(origTask.Cmds) > 0 {
		new.Cmds = make([]*ast.Cmd, 0, len(origTask.Cmds))
		for _, cmd := range origTask.Cmds {
			if cmd == nil {
				continue
			}
			if cmd.For != nil {
				list, keys, err := itemsFromFor(cmd.For, new.ComputeDir(), new.Sources, new.Generates, vars, origTask.Location, cache)
				if err != nil {
					return nil, err
				}
				// Name the iterator variable
				var as string
				if cmd.For.As != "" {
					as = cmd.For.As
				} else {
					as = "ITEM"
				}
				// Create a new command for each item in the list
				for i, loopValue := range list {
					extra := map[string]any{
						as: loopValue,
					}
					if len(keys) > 0 {
						extra["KEY"] = keys[i]
					}
					newCmd := cmd.DeepCopy()
					newCmd.Cmd = templater.ReplaceWithExtra(cmd.Cmd, cache, extra)
					newCmd.Task = templater.ReplaceWithExtra(cmd.Task, cache, extra)
					newCmd.If = templater.ReplaceWithExtra(cmd.If, cache, extra)
					newCmd.Vars = templater.ReplaceVarsWithExtra(cmd.Vars, cache, extra)
					new.Cmds = append(new.Cmds, newCmd)
				}
				continue
			}
			// Defer commands are replaced in a lazy manner because
			// we need to include EXIT_CODE.
			if cmd.Defer {
				new.Cmds = append(new.Cmds, cmd.DeepCopy())
				continue
			}
			newCmd := cmd.DeepCopy()
			newCmd.Cmd = templater.Replace(cmd.Cmd, cache)
			newCmd.Task = templater.Replace(cmd.Task, cache)
			newCmd.If = templater.Replace(cmd.If, cache)
			newCmd.Vars = templater.ReplaceVars(cmd.Vars, cache)
			new.Cmds = append(new.Cmds, newCmd)
		}
	}
	new.Setup, err = compileDeps(origTask.Setup, &new, vars, origTask.Location, cache)
	if err != nil {
		return nil, err
	}
	new.Deps, err = compileDeps(origTask.Deps, &new, vars, origTask.Location, cache)
	if err != nil {
		return nil, err
	}

	// Resolve "from:" entries in sources and generates by expanding them
	// into the sources/generates of the referenced tasks.
	if err := e.resolveGlobsFrom(&new, "sources"); err != nil {
		return nil, err
	}
	if err := e.resolveGlobsFrom(&new, "generates"); err != nil {
		return nil, err
	}

	// Recompute source hash if sources were extended by from: resolution,
	// so that the CHECKSUM reflects the full set of inputs.
	if hasFromEntries(origTask.Sources) && len(new.Sources) > 0 {
		checker := fingerprint.NewChecksumChecker(e.TempDir.Fingerprint, &new)
		new.SourceHash = checker.SourceValue()
		vars.Set("CHECKSUM", ast.Var{Live: new.SourceHash})
		cache.ResetCache()
	}

	if len(origTask.Preconditions) > 0 {
		new.Preconditions = make([]*ast.Precondition, 0, len(origTask.Preconditions))
		for _, precondition := range origTask.Preconditions {
			if precondition == nil {
				continue
			}
			newPrecondition := precondition.DeepCopy()
			newPrecondition.Sh = templater.Replace(precondition.Sh, cache)
			newPrecondition.Msg = templater.Replace(precondition.Msg, cache)
			new.Preconditions = append(new.Preconditions, newPrecondition)
		}
	}

	// Resolve cache fields — CHECKSUM is already available from above.
	if origTask.Cache != nil {
		resolved := origTask.Cache.DeepCopy()
		if resolved.Inherit != "" {
			if model, ok := e.Taskfile.Caches[resolved.Inherit]; ok && model != nil {
				merged := model.DeepCopy()
				if resolved.URL != "" {
					merged.URL = resolved.URL
				}
				if resolved.Lock != "" {
					merged.Lock = resolved.Lock
				}
				if resolved.If != "" {
					merged.If = resolved.If
				}
				if resolved.Enabled != nil {
					merged.Enabled = resolved.Enabled
				}
				if resolved.LockTimeout != "" {
					merged.LockTimeout = resolved.LockTimeout
				}
				resolved = merged
			}
		}
		resolved.Inherit = ""
		resolved.URL = templater.Replace(resolved.URL, cache)
		resolved.Lock = templater.Replace(resolved.Lock, cache)
		resolved.If = templater.Replace(resolved.If, cache)
		resolved.LockTimeout = templater.Replace(resolved.LockTimeout, cache)
		new.Cache = resolved
	}

	// Validate that cached tasks don't reference generates outside the
	// project root — such paths would escape the archive on extraction.
	if e.cacheEnabled(&new) && e.Dir != "" {
		taskDir := new.ComputeDir()
		for _, g := range new.Generates {
			resolved := filepathext.SmartJoin(taskDir, g.Glob)
			rel, err := filepath.Rel(e.Dir, resolved)
			if err != nil || strings.HasPrefix(rel, "..") {
				return nil, fmt.Errorf("task: %s: generates path %q is outside project root %q; caching requires all outputs to be within the project directory", new.Task, g.Glob, e.Dir)
			}
		}
	}

	// We only care about templater errors if we are evaluating shell variables
	if evaluateShVars && cache.Err() != nil {
		return &new, cache.Err()
	}

	return &new, nil
}

// hasFromEntries reports whether any Glob in the slice has a From directive.
func hasFromEntries(globs []*ast.Glob) bool {
	for _, g := range globs {
		if g.From != "" {
			return true
		}
	}
	return false
}

// resolveGlobsFrom expands "from:" entries in a task's sources or generates
// list (selected by field). Supported from: values:
//   - "deps": replaced by the same field of every direct dependency
//   - "cmds": replaced by the same field of every cmd task-call
//
// This allows wrapper tasks to inherit their children's sources/generates
// without duplicating glob patterns. Chaining works: if a child also uses
// "from:", its globs are resolved first via CompiledTask.
func (e *Executor) resolveGlobsFrom(t *ast.Task, field string) error {
	var globs *[]*ast.Glob
	switch field {
	case "sources":
		globs = &t.Sources
	case "generates":
		globs = &t.Generates
	default:
		return fmt.Errorf("task: %s: resolveGlobsFrom: unknown field %q", t.Task, field)
	}

	if !hasFromEntries(*globs) {
		return nil
	}

	getField := func(ct *ast.Task) []*ast.Glob {
		if field == "sources" {
			return ct.Sources
		}
		return ct.Generates
	}

	resolved := make([]*ast.Glob, 0, len(*globs))
	seen := make(map[string]bool)
	add := func(g *ast.Glob) {
		key := g.Glob
		if g.Negate {
			key = "!" + key
		}
		if g.Fingerprint != "" {
			key += "\x00fp:" + g.Fingerprint
		}
		if seen[key] {
			return
		}
		seen[key] = true
		resolved = append(resolved, g)
	}
	addFromTask := func(taskName string, vars *ast.Vars, fromKind string) error {
		ct, err := e.CompiledTask(&Call{Task: taskName, Vars: vars, Indirect: true})
		if err != nil {
			return fmt.Errorf("task: %s: %s: from: %s: resolving %q: %w", t.Task, field, fromKind, taskName, err)
		}
		for _, g := range getField(ct) {
			if g.From != "" {
				continue
			}
			add(g)
		}
		return nil
	}
	for _, g := range *globs {
		if g.From == "" {
			add(g)
			continue
		}
		switch g.From {
		case "deps":
			for _, dep := range t.Deps {
				if dep == nil {
					continue
				}
				if err := addFromTask(dep.Task, dep.Vars, "deps"); err != nil {
					return err
				}
			}
		case "cmds":
			for _, cmd := range t.Cmds {
				if cmd == nil || cmd.Task == "" {
					continue
				}
				if err := addFromTask(cmd.Task, cmd.Vars, "cmds"); err != nil {
					return err
				}
			}
		default:
			return fmt.Errorf("task: %s: %s: unsupported from: %q (expected \"deps\" or \"cmds\")", t.Task, field, g.From)
		}
	}
	*globs = resolved
	return nil
}

func asAnySlice[T any](slice []T) []any {
	ret := make([]any, len(slice))
	for i, v := range slice {
		ret[i] = v
	}
	return ret
}

func itemsFromFor(
	f *ast.For,
	dir string,
	sources []*ast.Glob,
	generates []*ast.Glob,
	vars *ast.Vars,
	location *ast.Location,
	cache *templater.Cache,
) ([]any, []string, error) {
	var keys []string // The list of keys to loop over (only if looping over a map)
	var values []any  // The list of values to loop over
	// Get the list from a matrix
	if f.Matrix.Len() != 0 {
		if err := resolveMatrixRefs(f.Matrix, cache); err != nil {
			return nil, nil, errors.TaskfileInvalidError{
				URI: location.Taskfile,
				Err: err,
			}
		}
		return asAnySlice(product(f.Matrix)), nil, nil
	}
	// Get the list from the explicit for list
	if len(f.List) > 0 {
		return f.List, nil, nil
	}
	// Get the list from the task sources
	if f.From == "sources" {
		glist, err := fingerprint.Globs(dir, sources)
		if err != nil {
			return nil, nil, err
		}
		// Make the paths relative to the task dir
		for i, v := range glist {
			if glist[i], err = filepath.Rel(dir, v); err != nil {
				return nil, nil, err
			}
		}
		values = asAnySlice(glist)
	}
	// Get the list from the task generates
	if f.From == "generates" {
		glist, err := fingerprint.Globs(dir, generates)
		if err != nil {
			return nil, nil, err
		}
		// Make the paths relative to the task dir
		for i, v := range glist {
			if glist[i], err = filepath.Rel(dir, v); err != nil {
				return nil, nil, err
			}
		}
		values = asAnySlice(glist)
	}
	// Get the list from a variable and split it up
	if f.Var != "" {
		if vars != nil {
			v, ok := vars.Get(f.Var)
			// If the variable is dynamic, then it hasn't been resolved yet
			// and we can't use it as a list. This happens when fast compiling a task
			// for use in --list or --list-all etc.
			if ok && v.Value != nil && v.Sh == nil {
				switch value := v.Value.(type) {
				case string:
					if f.Split != "" {
						values = asAnySlice(strings.Split(value, f.Split))
					} else {
						values = asAnySlice(strings.Fields(value))
					}
				case []string:
					values = asAnySlice(value)
				case []int:
					values = asAnySlice(value)
				case []any:
					values = value
				case map[string]any:
					for k, v := range value {
						keys = append(keys, k)
						values = append(values, v)
					}
				default:
					return nil, nil, errors.TaskfileInvalidError{
						URI: location.Taskfile,
						Err: errors.New("loop var must be a delimiter-separated string, list or a map"),
					}
				}
			}
		}
	}
	return values, keys, nil
}

func resolveMatrixRefs(matrix *ast.Matrix, cache *templater.Cache) error {
	if matrix.Len() == 0 {
		return nil
	}
	for _, row := range matrix.All() {
		if row.Ref != "" {
			v := templater.ResolveRef(row.Ref, cache)
			switch value := v.(type) {
			case []any:
				row.Value = value
			default:
				return fmt.Errorf("matrix reference %q must resolve to a list", row.Ref)
			}
		}
	}
	return nil
}

// product generates the cartesian product of the input map of slices.
func product(matrix *ast.Matrix) []map[string]any {
	if matrix.Len() == 0 {
		return nil
	}

	// Start with an empty product result
	result := []map[string]any{{}}

	// Iterate over each slice in the slices
	for key, row := range matrix.All() {
		var newResult []map[string]any

		// For each combination in the current result
		for _, combination := range result {
			// Append each element from the current slice to the combinations
			for _, item := range row.Value {
				newComb := make(map[string]any, len(combination))
				// Copy the existing combination
				maps.Copy(newComb, combination)
				// Add the current item with the corresponding key
				newComb[key] = item
				newResult = append(newResult, newComb)
			}
		}

		// Update result with the new combinations
		result = newResult
	}

	return result
}

// compileDeps resolves templates and for-loops in a list of deps.
// Used for both Setup and Deps fields.
func compileDeps(deps []*ast.Dep, t *ast.Task, vars *ast.Vars, location *ast.Location, cache *templater.Cache) ([]*ast.Dep, error) {
	if len(deps) == 0 {
		return nil, nil
	}
	result := make([]*ast.Dep, 0, len(deps))
	for _, dep := range deps {
		if dep == nil {
			continue
		}
		if dep.For != nil {
			list, keys, err := itemsFromFor(dep.For, t.ComputeDir(), t.Sources, t.Generates, vars, location, cache)
			if err != nil {
				return nil, err
			}
			var as string
			if dep.For.As != "" {
				as = dep.For.As
			} else {
				as = "ITEM"
			}
			for i, loopValue := range list {
				extra := map[string]any{
					as: loopValue,
				}
				if len(keys) > 0 {
					extra["KEY"] = keys[i]
				}
				newDep := dep.DeepCopy()
				newDep.Task = templater.ReplaceWithExtra(dep.Task, cache, extra)
				newDep.Vars = templater.ReplaceVarsWithExtra(dep.Vars, cache, extra)
				result = append(result, newDep)
			}
			continue
		}
		newDep := dep.DeepCopy()
		newDep.Task = templater.Replace(dep.Task, cache)
		newDep.Vars = templater.ReplaceVars(dep.Vars, cache)
		result = append(result, newDep)
	}
	return result, nil
}