Method ToEditorOutput

help.go:140–200

(tasks []*ast.Task, noStatus bool, nested bool)

}

func (e *Executor) ToEditorOutput(tasks []*ast.Task, noStatus bool, nested bool) (*editors.Namespace, error) {
	var g errgroup.Group
	editorTasks := make([]editors.Task, len(tasks))

	// Look over each task in parallel and turn it into an editor task
	for i := range tasks {
		g.Go(func() error {
			editorTask := editors.NewTask(tasks[i])

			if noStatus {
				editorTasks[i] = editorTask
				return nil
			}

			// Get the fingerprinting method to use
			method := e.Taskfile.Method
			if tasks[i].Method != "" {
				method = tasks[i].Method
			}
			upToDate, err := fingerprint.IsTaskUpToDate(context.Background(), tasks[i],
				fingerprint.WithMethod(method),
				fingerprint.WithTempDir(e.TempDir.Fingerprint),
				fingerprint.WithDry(e.Dry),
				fingerprint.WithLogger(e.Logger),
			)
			if err != nil {
				return err
			}

			editorTask.UpToDate = &upToDate
			editorTasks[i] = editorTask
			return nil
		})
	}
	if err := g.Wait(); err != nil {
		return nil, err
	}

	// Create the root namespace
	var tasksLen int
	if !nested {
		tasksLen = len(editorTasks)
	}
	rootNamespace := &editors.Namespace{
		Tasks:    make([]editors.Task, tasksLen),
		Location: e.Taskfile.Location,
	}

	// Recursively add namespaces to the root namespace or if nesting is
	// disabled add them all to the root namespace
	for i, task := range editorTasks {
		taskNamespacePath := strings.Split(task.Task, ast.NamespaceSeparator)
		if nested {
			rootNamespace.AddNamespace(taskNamespacePath, task)
		} else {
			rootNamespace.Tasks[i] = task
		}
	}