FilesExpand file tree

main

/

reader.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

79 lines (65 loc) · 1.8 KB

main

/

reader.go

Copy path

Top

File metadata and controls

• Code
• Blame

79 lines (65 loc) · 1.8 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

package taskrc

import (

"os"

"go.yaml.in/yaml/v3"

"github.com/go-task/task/v3/taskrc/ast"

)

type (

// DebugFunc is a function that can be called to log debug messages.

DebugFunc func(string)

// A ReaderOption is any type that can apply a configuration to a [Reader].

ReaderOption interface {

ApplyToReader(*Reader)

}

// A Reader will recursively read Taskfiles from a given [Node] and build a

// [ast.TaskRC] from them.

Reader struct {

debugFunc DebugFunc

}

)

// NewReader constructs a new Taskfile [Reader] using the given Node and

// options.

func NewReader(opts ...ReaderOption) *Reader {

r := &Reader{

debugFunc: nil,

}

r.Options(opts...)

return r

}

// Options loops through the given [ReaderOption] functions and applies them to

// the [Reader].

func (r *Reader) Options(opts ...ReaderOption) {

for _, opt := range opts {

opt.ApplyToReader(r)

}

}

// 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 DebugFunc) *debugFuncOption {

return &debugFuncOption{debugFunc: debugFunc}

}

type debugFuncOption struct {

debugFunc DebugFunc

}

func (o *debugFuncOption) ApplyToReader(r *Reader) {

r.debugFunc = o.debugFunc

}

// Read will read the Task config defined by the [Reader]'s [Node].

func (r *Reader) Read(node *Node) (*ast.TaskRC, error) {

var config ast.TaskRC

if node == nil {

return nil, os.ErrInvalid

}

// Read the file

b, err := os.ReadFile(node.entrypoint) //nolint:gosec

if err != nil {

return nil, err

}

// Parse the content

if err := yaml.Unmarshal(b, &config); err != nil {

return nil, err

}

return &config, nil

}