feat: remove logger from taskfile package (#2082)

* refactor: remove logger from the taskfile node interface

* refactor: functional options on taskfile.Reader

* feat: use pass in debug/prompt functions to Reader rather than task Logger

* chore: reader docstrings

* fix: typo

taskfile/reader.go

@@ -14,7 +14,6 @@ import (
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/compiler"
 	"github.com/go-task/task/v3/internal/filepathext"
-	"github.com/go-task/task/v3/internal/logger"
 	"github.com/go-task/task/v3/internal/templater"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
@@ -28,40 +27,115 @@ Continue?`
 Continue?`
 )
 
-// A Reader will recursively read Taskfiles from a given source using a directed
-// acyclic graph (DAG).
-type Reader struct {
-	graph       *ast.TaskfileGraph
-	node        Node
-	insecure    bool
-	download    bool
-	offline     bool
-	timeout     time.Duration
-	tempDir     string
-	logger      *logger.Logger
-	promptMutex sync.Mutex
-}
+type (
+	// ReaderDebugFunc is a function that is called when the reader wants to
+	// log debug messages
+	ReaderDebugFunc func(string)
+	// ReaderPromptFunc is a function that is called when the reader wants to
+	// prompt the user in some way
+	ReaderPromptFunc func(string) error
+	// ReaderOption is a function that configures a Reader.
+	ReaderOption func(*Reader)
+	// A Reader will recursively read Taskfiles from a given source using a directed
+	// acyclic graph (DAG).
+	Reader struct {
+		graph       *ast.TaskfileGraph
+		node        Node
+		insecure    bool
+		download    bool
+		offline     bool
+		timeout     time.Duration
+		tempDir     string
+		debugFunc   ReaderDebugFunc
+		promptFunc  ReaderPromptFunc
+		promptMutex sync.Mutex
+	}
+)
 
+// NewReader constructs a new Taskfile Reader using the given Node and options.
 func NewReader(
 	node Node,
-	insecure bool,
-	download bool,
-	offline bool,
-	timeout time.Duration,
-	tempDir string,
-	logger *logger.Logger,
+	opts ...ReaderOption,
 ) *Reader {
-	return &Reader{
+	reader := &Reader{
 		graph:       ast.NewTaskfileGraph(),
 		node:        node,
-		insecure:    insecure,
-		download:    download,
-		offline:     offline,
-		timeout:     timeout,
-		tempDir:     tempDir,
-		logger:      logger,
+		insecure:    false,
+		download:    false,
+		offline:     false,
+		timeout:     time.Second * 10,
+		tempDir:     os.TempDir(),
+		debugFunc:   nil,
+		promptFunc:  nil,
 		promptMutex: sync.Mutex{},
 	}
+	for _, opt := range opts {
+		opt(reader)
+	}
+	return reader
+}
+
+// WithInsecure enables insecure connections when reading remote taskfiles. By
+// default, insecure connections are rejected.
+func WithInsecure(insecure bool) ReaderOption {
+	return func(r *Reader) {
+		r.insecure = insecure
+	}
+}
+
+// WithDownload forces the reader to download a fresh copy of the taskfile from
+// the remote source.
+func WithDownload(download bool) ReaderOption {
+	return func(r *Reader) {
+		r.download = download
+	}
+}
+
+// WithOffline stops the reader from being able to make network connections.
+// It will still be able to read local files and cached copies of remote files.
+func WithOffline(offline bool) ReaderOption {
+	return func(r *Reader) {
+		r.offline = offline
+	}
+}
+
+// WithTimeout sets the timeout for reading remote taskfiles. By default, the
+// timeout is set to 10 seconds.
+func WithTimeout(timeout time.Duration) ReaderOption {
+	return func(r *Reader) {
+		r.timeout = timeout
+	}
+}
+
+// WithTempDir sets the temporary directory to be used by the reader. By
+// default, the reader uses `os.TempDir()`.
+func WithTempDir(tempDir string) ReaderOption {
+	return func(r *Reader) {
+		r.tempDir = tempDir
+	}
+}
+
+// WithDebugFunc sets the debug function to be used by the reader. If set, this
+// function will be called with debug messages. This can be useful if the caller
+// wants to log debug messages from the reader. By default, no debug function is
+// set and the logs are not written.
+func WithDebugFunc(debugFunc ReaderDebugFunc) ReaderOption {
+	return func(r *Reader) {
+		r.debugFunc = debugFunc
+	}
+}
+
+// WithPromptFunc sets the prompt function to be used by the reader. If set,
+// this function will be called with prompt messages. The function should
+// optionally log the message to the user and return nil if the prompt is
+// accepted and the execution should continue. Otherwise, it should return an
+// error which describes why the the prompt was rejected. This can then be
+// caught and used later when calling the Read method. By default, no prompt
+// function is set and all prompts are automatically accepted.
+func WithPromptFunc(promptFunc ReaderPromptFunc) ReaderOption {
+	return func(r *Reader) {
+		r.promptFunc = promptFunc
+	}
 }
 
 func (r *Reader) Read() (*ast.TaskfileGraph, error) {
@@ -73,6 +147,19 @@ func (r *Reader) Read() (*ast.TaskfileGraph, error) {
 	return r.graph, nil
 }
 
+func (r *Reader) debugf(format string, a ...any) {
+	if r.debugFunc != nil {
+		r.debugFunc(fmt.Sprintf(format, a...))
+	}
+}
+
+func (r *Reader) promptf(format string, a ...any) error {
+	if r.promptFunc != nil {
+		return r.promptFunc(fmt.Sprintf(format, a...))
+	}
+	return nil
+}
+
 func (r *Reader) include(node Node) error {
 	// Create a new vertex for the Taskfile
 	vertex := &ast.TaskfileVertex{
@@ -132,7 +219,7 @@ func (r *Reader) include(node Node) error {
 				return err
 			}
 
-			includeNode, err := NewNode(r.logger, entrypoint, include.Dir, r.insecure, r.timeout,
+			includeNode, err := NewNode(entrypoint, include.Dir, r.insecure, r.timeout,
 				WithParent(node),
 			)
 			if err != nil {
@@ -246,7 +333,7 @@ func (r *Reader) loadNodeContent(node Node) ([]byte, error) {
 		} else if err != nil {
 			return nil, err
 		}
-		r.logger.VerboseOutf(logger.Magenta, "task: [%s] Fetched cached copy\n", node.Location())
+		r.debugf("task: [%s] Fetched cached copy\n", node.Location())
 
 		return cached, nil
 	}
@@ -270,14 +357,14 @@ func (r *Reader) loadNodeContent(node Node) ([]byte, error) {
 		} else if err != nil {
 			return nil, err
 		}
-		r.logger.VerboseOutf(logger.Magenta, "task: [%s] Network timeout. Fetched cached copy\n", node.Location())
+		r.debugf("task: [%s] Network timeout. Fetched cached copy\n", node.Location())
 
 		return cached, nil
 
 	} else if err != nil {
 		return nil, err
 	}
-	r.logger.VerboseOutf(logger.Magenta, "task: [%s] Fetched remote copy\n", node.Location())
+	r.debugf("task: [%s] Fetched remote copy\n", node.Location())
 
 	// Get the checksums
 	checksum := checksum(b)
@@ -286,17 +373,17 @@ func (r *Reader) loadNodeContent(node Node) ([]byte, error) {
 	var prompt string
 	if cachedChecksum == "" {
 		// If the checksum doesn't exist, prompt the user to continue
-		prompt = fmt.Sprintf(taskfileUntrustedPrompt, node.Location())
+		prompt = taskfileUntrustedPrompt
 	} else if checksum != cachedChecksum {
 		// If there is a cached hash, but it doesn't match the expected hash, prompt the user to continue
-		prompt = fmt.Sprintf(taskfileChangedPrompt, node.Location())
+		prompt = taskfileChangedPrompt
 	}
 
 	if prompt != "" {
 		if err := func() error {
 			r.promptMutex.Lock()
 			defer r.promptMutex.Unlock()
-			return r.logger.Prompt(logger.Yellow, prompt, "n", "y", "yes")
+			return r.promptf(prompt, node.Location())
 		}(); err != nil {
 			return nil, &errors.TaskfileNotTrustedError{URI: node.Location()}
 		}
@@ -307,7 +394,7 @@ func (r *Reader) loadNodeContent(node Node) ([]byte, error) {
 		}
 
 		// Cache the file
-		r.logger.VerboseOutf(logger.Magenta, "task: [%s] Caching downloaded file\n", node.Location())
+		r.debugf("task: [%s] Caching downloaded file\n", node.Location())
 		if err = cache.write(node, b); err != nil {
 			return nil, err
 		}